projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
regulator: mc13783: add regulators sw1x and sw2x
[deliverable/linux.git] / drivers / regulator / lp872x.c
CommitLineData
af8b5fc3
KM		 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
92enum lp872x_id {
93 LP8720,
94 LP8725,
95};
96
97struct 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 */
109static 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 */
117static 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 */
125static 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 */
134static 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 */
142static 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 */
150static const unsigned int lp8725_buck_uA[] = {
151 460000, 780000, 1050000, 1370000,
152};
153
154static 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
169static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
170{
171 return regmap_write(lp->regmap, addr, data);
172}
173
174static 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
180static 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
194static 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
230static 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
272static 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
282static 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
321static 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
336static 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
354static 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
372static 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);
4e1d67ed
AL		 377 int i;
378 u8 addr;
af8b5fc3
KM		 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
4e1d67ed 391 for (i = ARRAY_SIZE(lp8725_buck_uA) - 1 ; i >= 0; i--) {
af8b5fc3
KM		 392 if (lp8725_buck_uA[i] >= min_uA &&
393 lp8725_buck_uA[i] <= max_uA)
4e1d67ed
AL		 394 return lp872x_update_bits(lp, addr,
395 LP8725_BUCK_CL_M,
396 i << LP8725_BUCK_CL_S);
397 }
af8b5fc3 398
4e1d67ed 399 return -EINVAL;
af8b5fc3
KM		 400}
401
402static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
403{
404 struct lp872x *lp = rdev_get_drvdata(rdev);
405 enum lp872x_regulator_id buck = rdev_get_id(rdev);
406 u8 addr, val;
407 int ret;
408
409 switch (buck) {
410 case LP8725_ID_BUCK1:
411 addr = LP8725_BUCK1_VOUT2;
412 break;
413 case LP8725_ID_BUCK2:
414 addr = LP8725_BUCK2_VOUT2;
415 break;
416 default:
417 return -EINVAL;
418 }
419
420 ret = lp872x_read_byte(lp, addr, &val);
421 if (ret)
422 return ret;
423
424 val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
425
426 return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
427 lp8725_buck_uA[val] : -EINVAL;
428}
429
430static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
431{
432 struct lp872x *lp = rdev_get_drvdata(rdev);
433 enum lp872x_regulator_id buck = rdev_get_id(rdev);
434 u8 addr, mask, shift, val;
435
436 switch (buck) {
437 case LP8720_ID_BUCK:
438 addr = LP8720_BUCK_VOUT2;
439 mask = LP8720_BUCK_FPWM_M;
440 shift = LP8720_BUCK_FPWM_S;
441 break;
442 case LP8725_ID_BUCK1:
443 addr = LP8725_BUCK_CTRL;
444 mask = LP8725_BUCK1_FPWM_M;
445 shift = LP8725_BUCK1_FPWM_S;
446 break;
447 case LP8725_ID_BUCK2:
448 addr = LP8725_BUCK_CTRL;
449 mask = LP8725_BUCK2_FPWM_M;
450 shift = LP8725_BUCK2_FPWM_S;
451 break;
452 default:
453 return -EINVAL;
454 }
455
456 if (mode == REGULATOR_MODE_FAST)
457 val = LP872X_FORCE_PWM << shift;
458 else if (mode == REGULATOR_MODE_NORMAL)
459 val = LP872X_AUTO_PWM << shift;
460 else
461 return -EINVAL;
462
463 return lp872x_update_bits(lp, addr, mask, val);
464}
465
466static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
467{
468 struct lp872x *lp = rdev_get_drvdata(rdev);
469 enum lp872x_regulator_id buck = rdev_get_id(rdev);
470 u8 addr, mask, val;
471 int ret;
472
473 switch (buck) {
474 case LP8720_ID_BUCK:
475 addr = LP8720_BUCK_VOUT2;
476 mask = LP8720_BUCK_FPWM_M;
477 break;
478 case LP8725_ID_BUCK1:
479 addr = LP8725_BUCK_CTRL;
480 mask = LP8725_BUCK1_FPWM_M;
481 break;
482 case LP8725_ID_BUCK2:
483 addr = LP8725_BUCK_CTRL;
484 mask = LP8725_BUCK2_FPWM_M;
485 break;
486 default:
487 return -EINVAL;
488 }
489
490 ret = lp872x_read_byte(lp, addr, &val);
491 if (ret)
492 return ret;
493
494 return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
495}
496
497static struct regulator_ops lp872x_ldo_ops = {
498 .list_voltage = regulator_list_voltage_table,
499 .set_voltage_sel = regulator_set_voltage_sel_regmap,
500 .get_voltage_sel = regulator_get_voltage_sel_regmap,
501 .enable = regulator_enable_regmap,
502 .disable = regulator_disable_regmap,
503 .is_enabled = regulator_is_enabled_regmap,
504 .enable_time = lp872x_regulator_enable_time,
505};
506
507static struct regulator_ops lp8720_buck_ops = {
508 .list_voltage = regulator_list_voltage_table,
509 .set_voltage_sel = lp872x_buck_set_voltage_sel,
510 .get_voltage_sel = lp872x_buck_get_voltage_sel,
511 .enable = regulator_enable_regmap,
512 .disable = regulator_disable_regmap,
513 .is_enabled = regulator_is_enabled_regmap,
514 .enable_time = lp872x_regulator_enable_time,
515 .set_mode = lp872x_buck_set_mode,
516 .get_mode = lp872x_buck_get_mode,
517};
518
519static struct regulator_ops lp8725_buck_ops = {
520 .list_voltage = regulator_list_voltage_table,
521 .set_voltage_sel = lp872x_buck_set_voltage_sel,
522 .get_voltage_sel = lp872x_buck_get_voltage_sel,
523 .enable = regulator_enable_regmap,
524 .disable = regulator_disable_regmap,
525 .is_enabled = regulator_is_enabled_regmap,
526 .enable_time = lp872x_regulator_enable_time,
527 .set_mode = lp872x_buck_set_mode,
528 .get_mode = lp872x_buck_get_mode,
529 .set_current_limit = lp8725_buck_set_current_limit,
530 .get_current_limit = lp8725_buck_get_current_limit,
531};
532
533static struct regulator_desc lp8720_regulator_desc[] = {
534 {
535 .name = "ldo1",
536 .id = LP8720_ID_LDO1,
537 .ops = &lp872x_ldo_ops,
538 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
539 .volt_table = lp872x_ldo_vtbl,
540 .type = REGULATOR_VOLTAGE,
541 .owner = THIS_MODULE,
542 .vsel_reg = LP872X_LDO1_VOUT,
543 .vsel_mask = LP872X_VOUT_M,
544 .enable_reg = LP8720_ENABLE,
545 .enable_mask = LP872X_EN_LDO1_M,
546 },
547 {
548 .name = "ldo2",
549 .id = LP8720_ID_LDO2,
550 .ops = &lp872x_ldo_ops,
551 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
552 .volt_table = lp872x_ldo_vtbl,
553 .type = REGULATOR_VOLTAGE,
554 .owner = THIS_MODULE,
555 .vsel_reg = LP872X_LDO2_VOUT,
556 .vsel_mask = LP872X_VOUT_M,
557 .enable_reg = LP8720_ENABLE,
558 .enable_mask = LP872X_EN_LDO2_M,
559 },
560 {
561 .name = "ldo3",
562 .id = LP8720_ID_LDO3,
563 .ops = &lp872x_ldo_ops,
564 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
565 .volt_table = lp872x_ldo_vtbl,
566 .type = REGULATOR_VOLTAGE,
567 .owner = THIS_MODULE,
568 .vsel_reg = LP872X_LDO3_VOUT,
569 .vsel_mask = LP872X_VOUT_M,
570 .enable_reg = LP8720_ENABLE,
571 .enable_mask = LP872X_EN_LDO3_M,
572 },
573 {
574 .name = "ldo4",
575 .id = LP8720_ID_LDO4,
576 .ops = &lp872x_ldo_ops,
577 .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
578 .volt_table = lp8720_ldo4_vtbl,
579 .type = REGULATOR_VOLTAGE,
580 .owner = THIS_MODULE,
581 .vsel_reg = LP872X_LDO4_VOUT,
582 .vsel_mask = LP872X_VOUT_M,
583 .enable_reg = LP8720_ENABLE,
584 .enable_mask = LP872X_EN_LDO4_M,
585 },
586 {
587 .name = "ldo5",
588 .id = LP8720_ID_LDO5,
589 .ops = &lp872x_ldo_ops,
590 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
591 .volt_table = lp872x_ldo_vtbl,
592 .type = REGULATOR_VOLTAGE,
593 .owner = THIS_MODULE,
594 .vsel_reg = LP872X_LDO5_VOUT,
595 .vsel_mask = LP872X_VOUT_M,
596 .enable_reg = LP8720_ENABLE,
597 .enable_mask = LP872X_EN_LDO5_M,
598 },
599 {
600 .name = "buck",
601 .id = LP8720_ID_BUCK,
602 .ops = &lp8720_buck_ops,
603 .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
604 .volt_table = lp8720_buck_vtbl,
605 .type = REGULATOR_VOLTAGE,
606 .owner = THIS_MODULE,
607 .enable_reg = LP8720_ENABLE,
608 .enable_mask = LP8720_EN_BUCK_M,
609 },
610};
611
612static struct regulator_desc lp8725_regulator_desc[] = {
613 {
614 .name = "ldo1",
615 .id = LP8725_ID_LDO1,
616 .ops = &lp872x_ldo_ops,
617 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
618 .volt_table = lp872x_ldo_vtbl,
619 .type = REGULATOR_VOLTAGE,
620 .owner = THIS_MODULE,
621 .vsel_reg = LP872X_LDO1_VOUT,
622 .vsel_mask = LP872X_VOUT_M,
623 .enable_reg = LP8725_LDO_CTRL,
624 .enable_mask = LP872X_EN_LDO1_M,
625 },
626 {
627 .name = "ldo2",
628 .id = LP8725_ID_LDO2,
629 .ops = &lp872x_ldo_ops,
630 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
631 .volt_table = lp872x_ldo_vtbl,
632 .type = REGULATOR_VOLTAGE,
633 .owner = THIS_MODULE,
634 .vsel_reg = LP872X_LDO2_VOUT,
635 .vsel_mask = LP872X_VOUT_M,
636 .enable_reg = LP8725_LDO_CTRL,
637 .enable_mask = LP872X_EN_LDO2_M,
638 },
639 {
640 .name = "ldo3",
641 .id = LP8725_ID_LDO3,
642 .ops = &lp872x_ldo_ops,
643 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
644 .volt_table = lp872x_ldo_vtbl,
645 .type = REGULATOR_VOLTAGE,
646 .owner = THIS_MODULE,
647 .vsel_reg = LP872X_LDO3_VOUT,
648 .vsel_mask = LP872X_VOUT_M,
649 .enable_reg = LP8725_LDO_CTRL,
650 .enable_mask = LP872X_EN_LDO3_M,
651 },
652 {
653 .name = "ldo4",
654 .id = LP8725_ID_LDO4,
655 .ops = &lp872x_ldo_ops,
656 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
657 .volt_table = lp872x_ldo_vtbl,
658 .type = REGULATOR_VOLTAGE,
659 .owner = THIS_MODULE,
660 .vsel_reg = LP872X_LDO4_VOUT,
661 .vsel_mask = LP872X_VOUT_M,
662 .enable_reg = LP8725_LDO_CTRL,
663 .enable_mask = LP872X_EN_LDO4_M,
664 },
665 {
666 .name = "ldo5",
667 .id = LP8725_ID_LDO5,
668 .ops = &lp872x_ldo_ops,
669 .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
670 .volt_table = lp872x_ldo_vtbl,
671 .type = REGULATOR_VOLTAGE,
672 .owner = THIS_MODULE,
673 .vsel_reg = LP872X_LDO5_VOUT,
674 .vsel_mask = LP872X_VOUT_M,
675 .enable_reg = LP8725_LDO_CTRL,
676 .enable_mask = LP872X_EN_LDO5_M,
677 },
678 {
679 .name = "lilo1",
680 .id = LP8725_ID_LILO1,
681 .ops = &lp872x_ldo_ops,
682 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
683 .volt_table = lp8725_lilo_vtbl,
684 .type = REGULATOR_VOLTAGE,
685 .owner = THIS_MODULE,
686 .vsel_reg = LP8725_LILO1_VOUT,
687 .vsel_mask = LP872X_VOUT_M,
688 .enable_reg = LP8725_LDO_CTRL,
689 .enable_mask = LP8725_EN_LILO1_M,
690 },
691 {
692 .name = "lilo2",
693 .id = LP8725_ID_LILO2,
694 .ops = &lp872x_ldo_ops,
695 .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
696 .volt_table = lp8725_lilo_vtbl,
697 .type = REGULATOR_VOLTAGE,
698 .owner = THIS_MODULE,
699 .vsel_reg = LP8725_LILO2_VOUT,
700 .vsel_mask = LP872X_VOUT_M,
701 .enable_reg = LP8725_LDO_CTRL,
702 .enable_mask = LP8725_EN_LILO2_M,
703 },
704 {
705 .name = "buck1",
706 .id = LP8725_ID_BUCK1,
707 .ops = &lp8725_buck_ops,
708 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
709 .volt_table = lp8725_buck_vtbl,
710 .type = REGULATOR_VOLTAGE,
711 .owner = THIS_MODULE,
712 .enable_reg = LP872X_GENERAL_CFG,
713 .enable_mask = LP8725_BUCK1_EN_M,
714 },
715 {
716 .name = "buck2",
717 .id = LP8725_ID_BUCK2,
718 .ops = &lp8725_buck_ops,
719 .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
720 .volt_table = lp8725_buck_vtbl,
721 .type = REGULATOR_VOLTAGE,
722 .owner = THIS_MODULE,
723 .enable_reg = LP872X_GENERAL_CFG,
724 .enable_mask = LP8725_BUCK2_EN_M,
725 },
726};
727
728static int lp872x_check_dvs_validity(struct lp872x *lp)
729{
730 struct lp872x_dvs *dvs = lp->pdata->dvs;
731 u8 val = 0;
732 int ret;
733
734 ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
735 if (ret)
736 return ret;
737
738 ret = 0;
739 if (lp->chipid == LP8720) {
740 if (val & LP8720_EXT_DVS_M)
741 ret = dvs ? 0 : -EINVAL;
742 } else {
743 if ((val & LP8725_DVS1_M) == EXTERN_DVS_USED)
744 ret = dvs ? 0 : -EINVAL;
745 }
746
747 return ret;
748}
749
750static int lp872x_init_dvs(struct lp872x *lp)
751{
752 int ret, gpio;
753 struct lp872x_dvs *dvs = lp->pdata->dvs;
754 enum lp872x_dvs_state pinstate;
755
756 ret = lp872x_check_dvs_validity(lp);
757 if (ret) {
758 dev_warn(lp->dev, "invalid dvs data: %d\n", ret);
759 return ret;
760 }
761
762 gpio = dvs->gpio;
763 if (!gpio_is_valid(gpio)) {
764 dev_err(lp->dev, "invalid gpio: %d\n", gpio);
765 return -EINVAL;
766 }
767
768 pinstate = dvs->init_state;
769 ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
770 if (ret) {
771 dev_err(lp->dev, "gpio request err: %d\n", ret);
772 return ret;
773 }
774
775 lp->dvs_pin = pinstate;
776 lp->dvs_gpio = gpio;
777
778 return 0;
779}
780
781static int lp872x_config(struct lp872x *lp)
782{
783 struct lp872x_platform_data *pdata = lp->pdata;
784 int ret;
785
af8b5fc3
KM		 786 if (!pdata->update_config)
787 return 0;
788
789 ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
790 if (ret)
791 return ret;
792
793 return lp872x_init_dvs(lp);
794}
795
796static struct regulator_init_data
5bae0628 797*lp872x_find_regulator_init_data(int id, struct lp872x *lp)
af8b5fc3 798{
5bae0628 799 int i;
af8b5fc3 800
5bae0628 801 for (i = 0; i < lp->num_regulators; i++) {
af8b5fc3 802 if (lp->pdata->regulator_data[i].id == id)
5bae0628
AL		 803 return lp->pdata->regulator_data[i].init_data;
804 }
af8b5fc3 805
5bae0628 806 return NULL;
af8b5fc3
KM		 807}
808
809static int lp872x_regulator_register(struct lp872x *lp)
810{
811 struct regulator_desc *desc;
812 struct regulator_config cfg = { };
813 struct regulator_dev *rdev;
814 int i, ret;
815
816 for (i = 0 ; i < lp->num_regulators ; i++) {
817 desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
818 &lp8725_regulator_desc[i];
819
820 cfg.dev = lp->dev;
5bae0628 821 cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
af8b5fc3
KM		 822 cfg.driver_data = lp;
823 cfg.regmap = lp->regmap;
824
825 rdev = regulator_register(desc, &cfg);
826 if (IS_ERR(rdev)) {
827 dev_err(lp->dev, "regulator register err");
828 ret = PTR_ERR(rdev);
829 goto err;
830 }
831
832 *(lp->regulators + i) = rdev;
833 }
834
835 return 0;
836err:
837 while (--i >= 0) {
838 rdev = *(lp->regulators + i);
839 regulator_unregister(rdev);
840 }
841 return ret;
842}
843
844static void lp872x_regulator_unregister(struct lp872x *lp)
845{
846 struct regulator_dev *rdev;
847 int i;
848
849 for (i = 0 ; i < lp->num_regulators ; i++) {
850 rdev = *(lp->regulators + i);
851 regulator_unregister(rdev);
852 }
853}
854
855static const struct regmap_config lp872x_regmap_config = {
856 .reg_bits = 8,
857 .val_bits = 8,
858 .max_register = MAX_REGISTERS,
859};
860
861static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
862{
863 struct lp872x *lp;
864 struct lp872x_platform_data *pdata = cl->dev.platform_data;
865 int ret, size, num_regulators;
866 const int lp872x_num_regulators[] = {
867 [LP8720] = LP8720_NUM_REGULATORS,
868 [LP8725] = LP8725_NUM_REGULATORS,
869 };
870
baf73e2c 871 if (!pdata) {
b222a817 872 dev_err(&cl->dev, "no platform data\n");
baf73e2c
AL		 873 return -EINVAL;
874 }
875
af8b5fc3
KM		 876 lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
877 if (!lp)
878 goto err_mem;
879
880 num_regulators = lp872x_num_regulators[id->driver_data];
881 size = sizeof(struct regulator_dev *) * num_regulators;
882
883 lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
884 if (!lp->regulators)
885 goto err_mem;
886
887 lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
888 if (IS_ERR(lp->regmap)) {
889 ret = PTR_ERR(lp->regmap);
890 dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
891 goto err_dev;
892 }
893
894 lp->dev = &cl->dev;
895 lp->pdata = pdata;
896 lp->chipid = id->driver_data;
897 lp->num_regulators = num_regulators;
898 i2c_set_clientdata(cl, lp);
899
900 ret = lp872x_config(lp);
901 if (ret)
902 goto err_dev;
903
904 return lp872x_regulator_register(lp);
905
906err_mem:
907 return -ENOMEM;
908err_dev:
909 return ret;
910}
911
912static int __devexit lp872x_remove(struct i2c_client *cl)
913{
914 struct lp872x *lp = i2c_get_clientdata(cl);
915
916 lp872x_regulator_unregister(lp);
917 return 0;
918}
919
920static const struct i2c_device_id lp872x_ids[] = {
921 {"lp8720", LP8720},
922 {"lp8725", LP8725},
923 { }
924};
925MODULE_DEVICE_TABLE(i2c, lp872x_ids);
926
927static struct i2c_driver lp872x_driver = {
928 .driver = {
929 .name = "lp872x",
930 .owner = THIS_MODULE,
931 },
932 .probe = lp872x_probe,
933 .remove = __devexit_p(lp872x_remove),
934 .id_table = lp872x_ids,
935};
936
937module_i2c_driver(lp872x_driver);
938
939MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
940MODULE_AUTHOR("Milo Kim");
941MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.134003 seconds and 5 git commands to generate.