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