Merge tag 'rproc-v5.3' of git://github.com/andersson/remoteproc
[sfrench/cifs-2.6.git] / drivers / regulator / lp872x.c
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
96 enum lp872x_id {
97         LP8720,
98         LP8725,
99 };
100
101 struct 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 */
111 static 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 */
119 static 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 */
127 static 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 */
136 static 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 */
144 static 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 */
152 static const unsigned int lp8725_buck_uA[] = {
153         460000, 780000, 1050000, 1370000,
154 };
155
156 static 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
171 static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
172 {
173         return regmap_write(lp->regmap, addr, data);
174 }
175
176 static 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
182 static 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
218 static 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
252 static 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
262 static 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
301 static 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
316 static 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
334 static 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
352 static 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
388 static 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
419 static 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
430 static 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
443 static 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
458 static 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
543 static 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
676 static 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
702 set_default_dvs_mode:
703         return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
704                                 default_dvs_mode[lp->chipid]);
705 }
706
707 static 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
734 static 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
746 init_dvs:
747         return lp872x_init_dvs(lp);
748 }
749
750 static 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
767 static 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
793 static 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
803 static 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
812 static 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
824 static 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         }
879 out:
880         return pdata;
881 }
882 #else
883 static 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
890 static 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
938 static const struct of_device_id lp872x_dt_ids[] = {
939         { .compatible = "ti,lp8720", },
940         { .compatible = "ti,lp8725", },
941         { }
942 };
943 MODULE_DEVICE_TABLE(of, lp872x_dt_ids);
944
945 static const struct i2c_device_id lp872x_ids[] = {
946         {"lp8720", LP8720},
947         {"lp8725", LP8725},
948         { }
949 };
950 MODULE_DEVICE_TABLE(i2c, lp872x_ids);
951
952 static 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
961 module_i2c_driver(lp872x_driver);
962
963 MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
964 MODULE_AUTHOR("Milo Kim");
965 MODULE_LICENSE("GPL");