?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adding support for MOXA ART SoC. Testing port of linux-2.6.32.60-moxart.
[linux-3.6.7-moxart.git] / drivers / regulator / lp872x.c
blob212c38eaba700d857767a89c2ccfc3d5006018e6
1 /*
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
89 /* dump registers in regmap-debugfs */
90 #define MAX_REGISTERS 0x0F
91
92 enum lp872x_id {
93 LP8720,
94 LP8725,
95 };
96
97 struct lp872x {
98 struct regmap *regmap;
99 struct device *dev;
100 enum lp872x_id chipid;
101 struct lp872x_platform_data *pdata;
102 struct regulator_dev **regulators;
103 int num_regulators;
104 enum lp872x_dvs_state dvs_pin;
105 int dvs_gpio;
106 };
107
108 /* LP8720/LP8725 shared voltage table for LDOs */
109 static const unsigned int lp872x_ldo_vtbl[] = {
110 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
111 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
112 2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
113 2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
114 };
115
116 /* LP8720 LDO4 voltage table */
117 static const unsigned int lp8720_ldo4_vtbl[] = {
118 800000, 850000, 900000, 1000000, 1100000, 1200000, 1250000, 1300000,
119 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
120 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
121 2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
122 };
123
124 /* LP8725 LILO(Low Input Low Output) voltage table */
125 static const unsigned int lp8725_lilo_vtbl[] = {
126 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
127 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
128 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
129 2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
130 };
131
132 /* LP8720 BUCK voltage table */
133 #define EXT_R 0 /* external resistor divider */
134 static const unsigned int lp8720_buck_vtbl[] = {
135 EXT_R, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
136 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
137 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
138 1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
139 };
140
141 /* LP8725 BUCK voltage table */
142 static const unsigned int lp8725_buck_vtbl[] = {
143 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
144 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
145 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
146 2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
147 };
148
149 /* LP8725 BUCK current limit */
150 static const unsigned int lp8725_buck_uA[] = {
151 460000, 780000, 1050000, 1370000,
152 };
153
154 static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
155 {
156 int ret;
157 unsigned int val;
158
159 ret = regmap_read(lp->regmap, addr, &val);
160 if (ret < 0) {
161 dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
162 return ret;
163 }
164
165 *data = (u8)val;
166 return 0;
167 }
168
169 static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
170 {
171 return regmap_write(lp->regmap, addr, data);
172 }
173
174 static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
175 unsigned int mask, u8 data)
176 {
177 return regmap_update_bits(lp->regmap, addr, mask, data);
178 }
179
180 static int _rdev_to_offset(struct regulator_dev *rdev)
181 {
182 enum lp872x_regulator_id id = rdev_get_id(rdev);
183
184 switch (id) {
185 case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
186 return id;
187 case LP8725_ID_LDO1 ... LP8725_ID_BUCK2:
188 return id - LP8725_ID_BASE;
189 default:
190 return -EINVAL;
191 }
192 }
193
194 static int lp872x_get_timestep_usec(struct lp872x *lp)
195 {
196 enum lp872x_id chip = lp->chipid;
197 u8 val, mask, shift;
198 int *time_usec, size, ret;
199 int lp8720_time_usec[] = { 25, 50 };
200 int lp8725_time_usec[] = { 32, 64, 128, 256 };
201
202 switch (chip) {
203 case LP8720:
204 mask = LP8720_TIMESTEP_M;
205 shift = LP8720_TIMESTEP_S;
206 time_usec = &lp8720_time_usec[0];
207 size = ARRAY_SIZE(lp8720_time_usec);
208 break;
209 case LP8725:
210 mask = LP8725_TIMESTEP_M;
211 shift = LP8725_TIMESTEP_S;
212 time_usec = &lp8725_time_usec[0];
213 size = ARRAY_SIZE(lp8725_time_usec);
214 break;
215 default:
216 return -EINVAL;
217 }
218
219 ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
220 if (ret)
221 return -EINVAL;
222
223 val = (val & mask) >> shift;
224 if (val >= size)
225 return -EINVAL;
226
227 return *(time_usec + val);
228 }
229
230 static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
231 {
232 struct lp872x *lp = rdev_get_drvdata(rdev);
233 enum lp872x_regulator_id regulator = rdev_get_id(rdev);
234 int time_step_us = lp872x_get_timestep_usec(lp);
235 int ret, offset;
236 u8 addr, val;
237
238 if (time_step_us < 0)
239 return -EINVAL;
240
241 switch (regulator) {
242 case LP8720_ID_LDO1 ... LP8720_ID_LDO5:
243 case LP8725_ID_LDO1 ... LP8725_ID_LILO2:
244 offset = _rdev_to_offset(rdev);
245 if (offset < 0)
246 return -EINVAL;
247
248 addr = LP872X_LDO1_VOUT + offset;
249 break;
250 case LP8720_ID_BUCK:
251 addr = LP8720_BUCK_VOUT1;
252 break;
253 case LP8725_ID_BUCK1:
254 addr = LP8725_BUCK1_VOUT1;
255 break;
256 case LP8725_ID_BUCK2:
257 addr = LP8725_BUCK2_VOUT1;
258 break;
259 default:
260 return -EINVAL;
261 }
262
263 ret = lp872x_read_byte(lp, addr, &val);
264 if (ret)
265 return ret;
266
267 val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
268
269 return val > MAX_DELAY ? 0 : val * time_step_us;
270 }
271
272 static void lp872x_set_dvs(struct lp872x *lp, int gpio)
273 {
274 enum lp872x_dvs_sel dvs_sel = lp->pdata->dvs->vsel;
275 enum lp872x_dvs_state state;
276
277 state = dvs_sel == SEL_V1 ? DVS_HIGH : DVS_LOW;
278 gpio_set_value(gpio, state);
279 lp->dvs_pin = state;
280 }
281
282 static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
283 enum lp872x_regulator_id buck)
284 {
285 u8 val, addr;
286
287 if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
288 return 0;
289
290 switch (buck) {
291 case LP8720_ID_BUCK:
292 if (val & LP8720_EXT_DVS_M) {
293 addr = (lp->dvs_pin == DVS_HIGH) ?
294 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
295 } else {
296 if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
297 return 0;
298
299 addr = val & LP8720_DVS_SEL_M ?
300 LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
301 }
302 break;
303 case LP8725_ID_BUCK1:
304 if (val & LP8725_DVS1_M)
305 addr = LP8725_BUCK1_VOUT1;
306 else
307 addr = (lp->dvs_pin == DVS_HIGH) ?
308 LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
309 break;
310 case LP8725_ID_BUCK2:
311 addr = val & LP8725_DVS2_M ?
312 LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
313 break;
314 default:
315 return 0;
316 }
317
318 return addr;
319 }
320
321 static bool lp872x_is_valid_buck_addr(u8 addr)
322 {
323 switch (addr) {
324 case LP8720_BUCK_VOUT1:
325 case LP8720_BUCK_VOUT2:
326 case LP8725_BUCK1_VOUT1:
327 case LP8725_BUCK1_VOUT2:
328 case LP8725_BUCK2_VOUT1:
329 case LP8725_BUCK2_VOUT2:
330 return true;
331 default:
332 return false;
333 }
334 }
335
336 static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
337 unsigned selector)
338 {
339 struct lp872x *lp = rdev_get_drvdata(rdev);
340 enum lp872x_regulator_id buck = rdev_get_id(rdev);
341 u8 addr, mask = LP872X_VOUT_M;
342 struct lp872x_dvs *dvs = lp->pdata->dvs;
343
344 if (dvs && gpio_is_valid(dvs->gpio))
345 lp872x_set_dvs(lp, dvs->gpio);
346
347 addr = lp872x_select_buck_vout_addr(lp, buck);
348 if (!lp872x_is_valid_buck_addr(addr))
349 return -EINVAL;
350
351 return lp872x_update_bits(lp, addr, mask, selector);
352 }
353
354 static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
355 {
356 struct lp872x *lp = rdev_get_drvdata(rdev);
357 enum lp872x_regulator_id buck = rdev_get_id(rdev);
358 u8 addr, val;
359 int ret;
360
361 addr = lp872x_select_buck_vout_addr(lp, buck);
362 if (!lp872x_is_valid_buck_addr(addr))
363 return -EINVAL;
364
365 ret = lp872x_read_byte(lp, addr, &val);
366 if (ret)
367 return ret;
368
369 return val & LP872X_VOUT_M;
370 }
371
372 static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
373 int min_uA, int max_uA)
374 {
375 struct lp872x *lp = rdev_get_drvdata(rdev);
376 enum lp872x_regulator_id buck = rdev_get_id(rdev);
377 int i, max = ARRAY_SIZE(lp8725_buck_uA);
378 u8 addr, val;
379
380 switch (buck) {
381 case LP8725_ID_BUCK1:
382 addr = LP8725_BUCK1_VOUT2;
383 break;
384 case LP8725_ID_BUCK2:
385 addr = LP8725_BUCK2_VOUT2;
386 break;
387 default:
388 return -EINVAL;
389 }
390
391 for (i = 0 ; i < max ; i++)
392 if (lp8725_buck_uA[i] >= min_uA &&
393 lp8725_buck_uA[i] <= max_uA)
394 break;
395
396 if (i == max)
397 return -EINVAL;
398
399 val = i << LP8725_BUCK_CL_S;
400
401 return lp872x_update_bits(lp, addr, LP8725_BUCK_CL_M, val);
402 }
403
404 static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
405 {
406 struct lp872x *lp = rdev_get_drvdata(rdev);
407 enum lp872x_regulator_id buck = rdev_get_id(rdev);
408 u8 addr, val;
409 int ret;
410
411 switch (buck) {
412 case LP8725_ID_BUCK1:
413 addr = LP8725_BUCK1_VOUT2;
414 break;
415 case LP8725_ID_BUCK2:
416 addr = LP8725_BUCK2_VOUT2;
417 break;
418 default:
419 return -EINVAL;
420 }
421
422 ret = lp872x_read_byte(lp, addr, &val);
423 if (ret)
424 return ret;
425
426 val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
427
428 return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
429 lp8725_buck_uA[val] : -EINVAL;
430 }
431
432 static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
433 {
434 struct lp872x *lp = rdev_get_drvdata(rdev);
435 enum lp872x_regulator_id buck = rdev_get_id(rdev);
436 u8 addr, mask, shift, val;
437
438 switch (buck) {
439 case LP8720_ID_BUCK:
440 addr = LP8720_BUCK_VOUT2;
441 mask = LP8720_BUCK_FPWM_M;
442 shift = LP8720_BUCK_FPWM_S;
443 break;
444 case LP8725_ID_BUCK1:
445 addr = LP8725_BUCK_CTRL;
446 mask = LP8725_BUCK1_FPWM_M;
447 shift = LP8725_BUCK1_FPWM_S;
448 break;
449 case LP8725_ID_BUCK2:
450 addr = LP8725_BUCK_CTRL;
451 mask = LP8725_BUCK2_FPWM_M;
452 shift = LP8725_BUCK2_FPWM_S;
453 break;
454 default:
455 return -EINVAL;
456 }
457
458 if (mode == REGULATOR_MODE_FAST)
459 val = LP872X_FORCE_PWM << shift;
460 else if (mode == REGULATOR_MODE_NORMAL)
461 val = LP872X_AUTO_PWM << shift;
462 else
463 return -EINVAL;
464
465 return lp872x_update_bits(lp, addr, mask, val);
466 }
467
468 static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
469 {
470 struct lp872x *lp = rdev_get_drvdata(rdev);
471 enum lp872x_regulator_id buck = rdev_get_id(rdev);
472 u8 addr, mask, val;
473 int ret;
474
475 switch (buck) {
476 case LP8720_ID_BUCK:
477 addr = LP8720_BUCK_VOUT2;
478 mask = LP8720_BUCK_FPWM_M;
479 break;
480 case LP8725_ID_BUCK1:
481 addr = LP8725_BUCK_CTRL;
482 mask = LP8725_BUCK1_FPWM_M;
483 break;
484 case LP8725_ID_BUCK2:
485 addr = LP8725_BUCK_CTRL;
486 mask = LP8725_BUCK2_FPWM_M;
487 break;
488 default:
489 return -EINVAL;
490 }
491
492 ret = lp872x_read_byte(lp, addr, &val);
493 if (ret)
494 return ret;
495
496 return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
497 }
498
499 static struct regulator_ops lp872x_ldo_ops = {
500 .list_voltage = regulator_list_voltage_table,
501 .set_voltage_sel = regulator_set_voltage_sel_regmap,
502 .get_voltage_sel = regulator_get_voltage_sel_regmap,
503 .enable = regulator_enable_regmap,
504 .disable = regulator_disable_regmap,
505 .is_enabled = regulator_is_enabled_regmap,
506 .enable_time = lp872x_regulator_enable_time,
507 };
508
509 static struct regulator_ops lp8720_buck_ops = {
510 .list_voltage = regulator_list_voltage_table,
511 .set_voltage_sel = lp872x_buck_set_voltage_sel,
512 .get_voltage_sel = lp872x_buck_get_voltage_sel,
513 .enable = regulator_enable_regmap,
514 .disable = regulator_disable_regmap,
515 .is_enabled = regulator_is_enabled_regmap,
516 .enable_time = lp872x_regulator_enable_time,
517 .set_mode = lp872x_buck_set_mode,
518 .get_mode = lp872x_buck_get_mode,
519 };
520
521 static struct regulator_ops lp8725_buck_ops = {
522 .list_voltage = regulator_list_voltage_table,
523 .set_voltage_sel = lp872x_buck_set_voltage_sel,
524 .get_voltage_sel = lp872x_buck_get_voltage_sel,
525 .enable = regulator_enable_regmap,
526 .disable = regulator_disable_regmap,
527 .is_enabled = regulator_is_enabled_regmap,
528 .enable_time = lp872x_regulator_enable_time,
529 .set_mode = lp872x_buck_set_mode,
530 .get_mode = lp872x_buck_get_mode,
531 .set_current_limit = lp8725_buck_set_current_limit,
532 .get_current_limit = lp8725_buck_get_current_limit,
533 };
534
535 static struct regulator_desc lp8720_regulator_desc[] = {
536 {
537 .name = "ldo1",
538 .id = LP8720_ID_LDO1,
539 .ops = &lp872x_ldo_ops,
540 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
541 .volt_table = lp872x_ldo_vtbl,
542 .type = REGULATOR_VOLTAGE,
543 .owner = THIS_MODULE,
544 .vsel_reg = LP872X_LDO1_VOUT,
545 .vsel_mask = LP872X_VOUT_M,
546 .enable_reg = LP8720_ENABLE,
547 .enable_mask = LP872X_EN_LDO1_M,
548 },
549 {
550 .name = "ldo2",
551 .id = LP8720_ID_LDO2,
552 .ops = &lp872x_ldo_ops,
553 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
554 .volt_table = lp872x_ldo_vtbl,
555 .type = REGULATOR_VOLTAGE,
556 .owner = THIS_MODULE,
557 .vsel_reg = LP872X_LDO2_VOUT,
558 .vsel_mask = LP872X_VOUT_M,
559 .enable_reg = LP8720_ENABLE,
560 .enable_mask = LP872X_EN_LDO2_M,
561 },
562 {
563 .name = "ldo3",
564 .id = LP8720_ID_LDO3,
565 .ops = &lp872x_ldo_ops,
566 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
567 .volt_table = lp872x_ldo_vtbl,
568 .type = REGULATOR_VOLTAGE,
569 .owner = THIS_MODULE,
570 .vsel_reg = LP872X_LDO3_VOUT,
571 .vsel_mask = LP872X_VOUT_M,
572 .enable_reg = LP8720_ENABLE,
573 .enable_mask = LP872X_EN_LDO3_M,
574 },
575 {
576 .name = "ldo4",
577 .id = LP8720_ID_LDO4,
578 .ops = &lp872x_ldo_ops,
579 .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
580 .volt_table = lp8720_ldo4_vtbl,
581 .type = REGULATOR_VOLTAGE,
582 .owner = THIS_MODULE,
583 .vsel_reg = LP872X_LDO4_VOUT,
584 .vsel_mask = LP872X_VOUT_M,
585 .enable_reg = LP8720_ENABLE,
586 .enable_mask = LP872X_EN_LDO4_M,
587 },
588 {
589 .name = "ldo5",
590 .id = LP8720_ID_LDO5,
591 .ops = &lp872x_ldo_ops,
592 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
593 .volt_table = lp872x_ldo_vtbl,
594 .type = REGULATOR_VOLTAGE,
595 .owner = THIS_MODULE,
596 .vsel_reg = LP872X_LDO5_VOUT,
597 .vsel_mask = LP872X_VOUT_M,
598 .enable_reg = LP8720_ENABLE,
599 .enable_mask = LP872X_EN_LDO5_M,
600 },
601 {
602 .name = "buck",
603 .id = LP8720_ID_BUCK,
604 .ops = &lp8720_buck_ops,
605 .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
606 .volt_table = lp8720_buck_vtbl,
607 .type = REGULATOR_VOLTAGE,
608 .owner = THIS_MODULE,
609 .enable_reg = LP8720_ENABLE,
610 .enable_mask = LP8720_EN_BUCK_M,
611 },
612 };
613
614 static struct regulator_desc lp8725_regulator_desc[] = {
615 {
616 .name = "ldo1",
617 .id = LP8725_ID_LDO1,
618 .ops = &lp872x_ldo_ops,
619 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
620 .volt_table = lp872x_ldo_vtbl,
621 .type = REGULATOR_VOLTAGE,
622 .owner = THIS_MODULE,
623 .vsel_reg = LP872X_LDO1_VOUT,
624 .vsel_mask = LP872X_VOUT_M,
625 .enable_reg = LP8725_LDO_CTRL,
626 .enable_mask = LP872X_EN_LDO1_M,
627 },
628 {
629 .name = "ldo2",
630 .id = LP8725_ID_LDO2,
631 .ops = &lp872x_ldo_ops,
632 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
633 .volt_table = lp872x_ldo_vtbl,
634 .type = REGULATOR_VOLTAGE,
635 .owner = THIS_MODULE,
636 .vsel_reg = LP872X_LDO2_VOUT,
637 .vsel_mask = LP872X_VOUT_M,
638 .enable_reg = LP8725_LDO_CTRL,
639 .enable_mask = LP872X_EN_LDO2_M,
640 },
641 {
642 .name = "ldo3",
643 .id = LP8725_ID_LDO3,
644 .ops = &lp872x_ldo_ops,
645 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
646 .volt_table = lp872x_ldo_vtbl,
647 .type = REGULATOR_VOLTAGE,
648 .owner = THIS_MODULE,
649 .vsel_reg = LP872X_LDO3_VOUT,
650 .vsel_mask = LP872X_VOUT_M,
651 .enable_reg = LP8725_LDO_CTRL,
652 .enable_mask = LP872X_EN_LDO3_M,
653 },
654 {
655 .name = "ldo4",
656 .id = LP8725_ID_LDO4,
657 .ops = &lp872x_ldo_ops,
658 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
659 .volt_table = lp872x_ldo_vtbl,
660 .type = REGULATOR_VOLTAGE,
661 .owner = THIS_MODULE,
662 .vsel_reg = LP872X_LDO4_VOUT,
663 .vsel_mask = LP872X_VOUT_M,
664 .enable_reg = LP8725_LDO_CTRL,
665 .enable_mask = LP872X_EN_LDO4_M,
666 },
667 {
668 .name = "ldo5",
669 .id = LP8725_ID_LDO5,
670 .ops = &lp872x_ldo_ops,
671 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
672 .volt_table = lp872x_ldo_vtbl,
673 .type = REGULATOR_VOLTAGE,
674 .owner = THIS_MODULE,
675 .vsel_reg = LP872X_LDO5_VOUT,
676 .vsel_mask = LP872X_VOUT_M,
677 .enable_reg = LP8725_LDO_CTRL,
678 .enable_mask = LP872X_EN_LDO5_M,
679 },
680 {
681 .name = "lilo1",
682 .id = LP8725_ID_LILO1,
683 .ops = &lp872x_ldo_ops,
684 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
685 .volt_table = lp8725_lilo_vtbl,
686 .type = REGULATOR_VOLTAGE,
687 .owner = THIS_MODULE,
688 .vsel_reg = LP8725_LILO1_VOUT,
689 .vsel_mask = LP872X_VOUT_M,
690 .enable_reg = LP8725_LDO_CTRL,
691 .enable_mask = LP8725_EN_LILO1_M,
692 },
693 {
694 .name = "lilo2",
695 .id = LP8725_ID_LILO2,
696 .ops = &lp872x_ldo_ops,
697 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
698 .volt_table = lp8725_lilo_vtbl,
699 .type = REGULATOR_VOLTAGE,
700 .owner = THIS_MODULE,
701 .vsel_reg = LP8725_LILO2_VOUT,
702 .vsel_mask = LP872X_VOUT_M,
703 .enable_reg = LP8725_LDO_CTRL,
704 .enable_mask = LP8725_EN_LILO2_M,
705 },
706 {
707 .name = "buck1",
708 .id = LP8725_ID_BUCK1,
709 .ops = &lp8725_buck_ops,
710 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
711 .volt_table = lp8725_buck_vtbl,
712 .type = REGULATOR_VOLTAGE,
713 .owner = THIS_MODULE,
714 .enable_reg = LP872X_GENERAL_CFG,
715 .enable_mask = LP8725_BUCK1_EN_M,
716 },
717 {
718 .name = "buck2",
719 .id = LP8725_ID_BUCK2,
720 .ops = &lp8725_buck_ops,
721 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
722 .volt_table = lp8725_buck_vtbl,
723 .type = REGULATOR_VOLTAGE,
724 .owner = THIS_MODULE,
725 .enable_reg = LP872X_GENERAL_CFG,
726 .enable_mask = LP8725_BUCK2_EN_M,
727 },
728 };
729
730 static int lp872x_check_dvs_validity(struct lp872x *lp)
731 {
732 struct lp872x_dvs *dvs = lp->pdata->dvs;
733 u8 val = 0;
734 int ret;
735
736 ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
737 if (ret)
738 return ret;
739
740 ret = 0;
741 if (lp->chipid == LP8720) {
742 if (val & LP8720_EXT_DVS_M)
743 ret = dvs ? 0 : -EINVAL;
744 } else {
745 if ((val & LP8725_DVS1_M) == EXTERN_DVS_USED)
746 ret = dvs ? 0 : -EINVAL;
747 }
748
749 return ret;
750 }
751
752 static int lp872x_init_dvs(struct lp872x *lp)
753 {
754 int ret, gpio;
755 struct lp872x_dvs *dvs = lp->pdata->dvs;
756 enum lp872x_dvs_state pinstate;
757
758 ret = lp872x_check_dvs_validity(lp);
759 if (ret) {
760 dev_warn(lp->dev, "invalid dvs data: %d\n", ret);
761 return ret;
762 }
763
764 gpio = dvs->gpio;
765 if (!gpio_is_valid(gpio)) {
766 dev_err(lp->dev, "invalid gpio: %d\n", gpio);
767 return -EINVAL;
768 }
769
770 pinstate = dvs->init_state;
771 ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
772 if (ret) {
773 dev_err(lp->dev, "gpio request err: %d\n", ret);
774 return ret;
775 }
776
777 lp->dvs_pin = pinstate;
778 lp->dvs_gpio = gpio;
779
780 return 0;
781 }
782
783 static int lp872x_config(struct lp872x *lp)
784 {
785 struct lp872x_platform_data *pdata = lp->pdata;
786 int ret;
787
788 if (!pdata->update_config)
789 return 0;
790
791 ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
792 if (ret)
793 return ret;
794
795 return lp872x_init_dvs(lp);
796 }
797
798 static struct regulator_init_data
799 *lp872x_find_regulator_init_data(int id, struct lp872x *lp)
800 {
801 int i;
802
803 for (i = 0; i < lp->num_regulators; i++) {
804 if (lp->pdata->regulator_data[i].id == id)
805 return lp->pdata->regulator_data[i].init_data;
806 }
807
808 return NULL;
809 }
810
811 static int lp872x_regulator_register(struct lp872x *lp)
812 {
813 struct regulator_desc *desc;
814 struct regulator_config cfg = { };
815 struct regulator_dev *rdev;
816 int i, ret;
817
818 for (i = 0 ; i < lp->num_regulators ; i++) {
819 desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
820 &lp8725_regulator_desc[i];
821
822 cfg.dev = lp->dev;
823 cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
824 cfg.driver_data = lp;
825 cfg.regmap = lp->regmap;
826
827 rdev = regulator_register(desc, &cfg);
828 if (IS_ERR(rdev)) {
829 dev_err(lp->dev, "regulator register err");
830 ret = PTR_ERR(rdev);
831 goto err;
832 }
833
834 *(lp->regulators + i) = rdev;
835 }
836
837 return 0;
838 err:
839 while (--i >= 0) {
840 rdev = *(lp->regulators + i);
841 regulator_unregister(rdev);
842 }
843 return ret;
844 }
845
846 static void lp872x_regulator_unregister(struct lp872x *lp)
847 {
848 struct regulator_dev *rdev;
849 int i;
850
851 for (i = 0 ; i < lp->num_regulators ; i++) {
852 rdev = *(lp->regulators + i);
853 regulator_unregister(rdev);
854 }
855 }
856
857 static const struct regmap_config lp872x_regmap_config = {
858 .reg_bits = 8,
859 .val_bits = 8,
860 .max_register = MAX_REGISTERS,
861 };
862
863 static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
864 {
865 struct lp872x *lp;
866 struct lp872x_platform_data *pdata = cl->dev.platform_data;
867 int ret, size, num_regulators;
868 const int lp872x_num_regulators[] = {
869 [LP8720] = LP8720_NUM_REGULATORS,
870 [LP8725] = LP8725_NUM_REGULATORS,
871 };
872
873 if (!pdata) {
874 dev_err(&cl->dev, "no platform data\n");
875 return -EINVAL;
876 }
877
878 lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
879 if (!lp)
880 goto err_mem;
881
882 num_regulators = lp872x_num_regulators[id->driver_data];
883 size = sizeof(struct regulator_dev *) * num_regulators;
884
885 lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
886 if (!lp->regulators)
887 goto err_mem;
888
889 lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
890 if (IS_ERR(lp->regmap)) {
891 ret = PTR_ERR(lp->regmap);
892 dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
893 goto err_dev;
894 }
895
896 lp->dev = &cl->dev;
897 lp->pdata = pdata;
898 lp->chipid = id->driver_data;
899 lp->num_regulators = num_regulators;
900 i2c_set_clientdata(cl, lp);
901
902 ret = lp872x_config(lp);
903 if (ret)
904 goto err_dev;
905
906 return lp872x_regulator_register(lp);
907
908 err_mem:
909 return -ENOMEM;
910 err_dev:
911 return ret;
912 }
913
914 static int __devexit lp872x_remove(struct i2c_client *cl)
915 {
916 struct lp872x *lp = i2c_get_clientdata(cl);
917
918 lp872x_regulator_unregister(lp);
919 return 0;
920 }
921
922 static const struct i2c_device_id lp872x_ids[] = {
923 {"lp8720", LP8720},
924 {"lp8725", LP8725},
925 { }
926 };
927 MODULE_DEVICE_TABLE(i2c, lp872x_ids);
928
929 static struct i2c_driver lp872x_driver = {
930 .driver = {
931 .name = "lp872x",
932 .owner = THIS_MODULE,
933 },
934 .probe = lp872x_probe,
935 .remove = __devexit_p(lp872x_remove),
936 .id_table = lp872x_ids,
937 };
938
939 module_i2c_driver(lp872x_driver);
940
941 MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
942 MODULE_AUTHOR("Milo Kim");
943 MODULE_LICENSE("GPL");
Linux ARM platform port for MOXA ART SoC