regulator: hi6421: Describe consumed platform device
[muen/linux.git] / drivers / regulator / hi6421-regulator.c
1 /*
2  * Device driver for regulators in Hi6421 IC
3  *
4  * Copyright (c) <2011-2014> HiSilicon Technologies Co., Ltd.
5  *              http://www.hisilicon.com
6  * Copyright (c) <2013-2014> Linaro Ltd.
7  *              http://www.linaro.org
8  *
9  * Author: Guodong Xu <guodong.xu@linaro.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  */
15
16 #include <linux/slab.h>
17 #include <linux/device.h>
18 #include <linux/module.h>
19 #include <linux/err.h>
20 #include <linux/platform_device.h>
21 #include <linux/of.h>
22 #include <linux/regmap.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/of_regulator.h>
26 #include <linux/mfd/hi6421-pmic.h>
27
28 /*
29  * struct hi6421_regulator_pdata - Hi6421 regulator data of platform device
30  * @lock: mutex to serialize regulator enable
31  */
32 struct hi6421_regulator_pdata {
33         struct mutex lock;
34 };
35
36 /*
37  * struct hi6421_regulator_info - hi6421 regulator information
38  * @desc: regulator description
39  * @mode_mask: ECO mode bitmask of LDOs; for BUCKs, this masks sleep
40  * @eco_microamp: eco mode load upper limit (in uA), valid for LDOs only
41  */
42 struct hi6421_regulator_info {
43         struct regulator_desc   desc;
44         u8              mode_mask;
45         u32             eco_microamp;
46 };
47
48 /* HI6421 regulators */
49 enum hi6421_regulator_id {
50         HI6421_LDO0,
51         HI6421_LDO1,
52         HI6421_LDO2,
53         HI6421_LDO3,
54         HI6421_LDO4,
55         HI6421_LDO5,
56         HI6421_LDO6,
57         HI6421_LDO7,
58         HI6421_LDO8,
59         HI6421_LDO9,
60         HI6421_LDO10,
61         HI6421_LDO11,
62         HI6421_LDO12,
63         HI6421_LDO13,
64         HI6421_LDO14,
65         HI6421_LDO15,
66         HI6421_LDO16,
67         HI6421_LDO17,
68         HI6421_LDO18,
69         HI6421_LDO19,
70         HI6421_LDO20,
71         HI6421_LDOAUDIO,
72         HI6421_BUCK0,
73         HI6421_BUCK1,
74         HI6421_BUCK2,
75         HI6421_BUCK3,
76         HI6421_BUCK4,
77         HI6421_BUCK5,
78         HI6421_NUM_REGULATORS,
79 };
80
81 #define HI6421_REGULATOR_OF_MATCH(_name, id)                            \
82 {                                                                       \
83         .name = #_name,                                                 \
84         .driver_data = (void *) HI6421_##id,                            \
85 }
86
87 static struct of_regulator_match hi6421_regulator_match[] = {
88         HI6421_REGULATOR_OF_MATCH(hi6421_vout0, LDO0),
89         HI6421_REGULATOR_OF_MATCH(hi6421_vout1, LDO1),
90         HI6421_REGULATOR_OF_MATCH(hi6421_vout2, LDO2),
91         HI6421_REGULATOR_OF_MATCH(hi6421_vout3, LDO3),
92         HI6421_REGULATOR_OF_MATCH(hi6421_vout4, LDO4),
93         HI6421_REGULATOR_OF_MATCH(hi6421_vout5, LDO5),
94         HI6421_REGULATOR_OF_MATCH(hi6421_vout6, LDO6),
95         HI6421_REGULATOR_OF_MATCH(hi6421_vout7, LDO7),
96         HI6421_REGULATOR_OF_MATCH(hi6421_vout8, LDO8),
97         HI6421_REGULATOR_OF_MATCH(hi6421_vout9, LDO9),
98         HI6421_REGULATOR_OF_MATCH(hi6421_vout10, LDO10),
99         HI6421_REGULATOR_OF_MATCH(hi6421_vout11, LDO11),
100         HI6421_REGULATOR_OF_MATCH(hi6421_vout12, LDO12),
101         HI6421_REGULATOR_OF_MATCH(hi6421_vout13, LDO13),
102         HI6421_REGULATOR_OF_MATCH(hi6421_vout14, LDO14),
103         HI6421_REGULATOR_OF_MATCH(hi6421_vout15, LDO15),
104         HI6421_REGULATOR_OF_MATCH(hi6421_vout16, LDO16),
105         HI6421_REGULATOR_OF_MATCH(hi6421_vout17, LDO17),
106         HI6421_REGULATOR_OF_MATCH(hi6421_vout18, LDO18),
107         HI6421_REGULATOR_OF_MATCH(hi6421_vout19, LDO19),
108         HI6421_REGULATOR_OF_MATCH(hi6421_vout20, LDO20),
109         HI6421_REGULATOR_OF_MATCH(hi6421_vout_audio, LDOAUDIO),
110         HI6421_REGULATOR_OF_MATCH(hi6421_buck0, BUCK0),
111         HI6421_REGULATOR_OF_MATCH(hi6421_buck1, BUCK1),
112         HI6421_REGULATOR_OF_MATCH(hi6421_buck2, BUCK2),
113         HI6421_REGULATOR_OF_MATCH(hi6421_buck3, BUCK3),
114         HI6421_REGULATOR_OF_MATCH(hi6421_buck4, BUCK4),
115         HI6421_REGULATOR_OF_MATCH(hi6421_buck5, BUCK5),
116 };
117
118 /* LDO 0, 4~7, 9~14, 16~20 have same voltage table. */
119 static const unsigned int ldo_0_voltages[] = {
120         1500000, 1800000, 2400000, 2500000,
121         2600000, 2700000, 2850000, 3000000,
122 };
123
124 /* LDO 8, 15 have same voltage table. */
125 static const unsigned int ldo_8_voltages[] = {
126         1500000, 1800000, 2400000, 2600000,
127         2700000, 2850000, 3000000, 3300000,
128 };
129
130 /* Ranges are sorted in ascending order. */
131 static const struct regulator_linear_range ldo_audio_volt_range[] = {
132         REGULATOR_LINEAR_RANGE(2800000, 0, 3, 50000),
133         REGULATOR_LINEAR_RANGE(3000000, 4, 7, 100000),
134 };
135
136 static const unsigned int buck_3_voltages[] = {
137          950000, 1050000, 1100000, 1117000,
138         1134000, 1150000, 1167000, 1200000,
139 };
140
141 static const unsigned int buck_4_voltages[] = {
142         1150000, 1200000, 1250000, 1350000,
143         1700000, 1800000, 1900000, 2000000,
144 };
145
146 static const unsigned int buck_5_voltages[] = {
147         1150000, 1200000, 1250000, 1350000,
148         1600000, 1700000, 1800000, 1900000,
149 };
150
151 static const struct regulator_ops hi6421_ldo_ops;
152 static const struct regulator_ops hi6421_ldo_linear_ops;
153 static const struct regulator_ops hi6421_ldo_linear_range_ops;
154 static const struct regulator_ops hi6421_buck012_ops;
155 static const struct regulator_ops hi6421_buck345_ops;
156
157 #define HI6421_LDO_ENABLE_TIME (350)
158 /*
159  * _id - LDO id name string
160  * v_table - voltage table
161  * vreg - voltage select register
162  * vmask - voltage select mask
163  * ereg - enable register
164  * emask - enable mask
165  * odelay - off/on delay time in uS
166  * ecomask - eco mode mask
167  * ecoamp - eco mode load uppler limit in uA
168  */
169 #define HI6421_LDO(_id, v_table, vreg, vmask, ereg, emask,              \
170                    odelay, ecomask, ecoamp)                             \
171         [HI6421_##_id] = {                                              \
172                 .desc = {                                               \
173                         .name           = #_id,                         \
174                         .ops            = &hi6421_ldo_ops,              \
175                         .type           = REGULATOR_VOLTAGE,            \
176                         .id             = HI6421_##_id,                 \
177                         .owner          = THIS_MODULE,                  \
178                         .n_voltages     = ARRAY_SIZE(v_table),          \
179                         .volt_table     = v_table,                      \
180                         .vsel_reg       = HI6421_REG_TO_BUS_ADDR(vreg), \
181                         .vsel_mask      = vmask,                        \
182                         .enable_reg     = HI6421_REG_TO_BUS_ADDR(ereg), \
183                         .enable_mask    = emask,                        \
184                         .enable_time    = HI6421_LDO_ENABLE_TIME,       \
185                         .off_on_delay   = odelay,                       \
186                 },                                                      \
187                 .mode_mask              = ecomask,                      \
188                 .eco_microamp           = ecoamp,                       \
189         }
190
191 /* HI6421 LDO1~3 are linear voltage regulators at fixed uV_step
192  *
193  * _id - LDO id name string
194  * _min_uV - minimum voltage supported in uV
195  * n_volt - number of votages available
196  * vstep - voltage increase in each linear step in uV
197  * vreg - voltage select register
198  * vmask - voltage select mask
199  * ereg - enable register
200  * emask - enable mask
201  * odelay - off/on delay time in uS
202  * ecomask - eco mode mask
203  * ecoamp - eco mode load uppler limit in uA
204  */
205 #define HI6421_LDO_LINEAR(_id, _min_uV, n_volt, vstep, vreg, vmask,     \
206                           ereg, emask, odelay, ecomask, ecoamp)         \
207         [HI6421_##_id] = {                                              \
208                 .desc = {                                               \
209                         .name           = #_id,                         \
210                         .ops            = &hi6421_ldo_linear_ops,       \
211                         .type           = REGULATOR_VOLTAGE,            \
212                         .id             = HI6421_##_id,                 \
213                         .owner          = THIS_MODULE,                  \
214                         .min_uV         = _min_uV,                      \
215                         .n_voltages     = n_volt,                       \
216                         .uV_step        = vstep,                        \
217                         .vsel_reg       = HI6421_REG_TO_BUS_ADDR(vreg), \
218                         .vsel_mask      = vmask,                        \
219                         .enable_reg     = HI6421_REG_TO_BUS_ADDR(ereg), \
220                         .enable_mask    = emask,                        \
221                         .enable_time    = HI6421_LDO_ENABLE_TIME,       \
222                         .off_on_delay   = odelay,                       \
223                 },                                                      \
224                 .mode_mask              = ecomask,                      \
225                 .eco_microamp           = ecoamp,                       \
226         }
227
228 /* HI6421 LDOAUDIO is a linear voltage regulator with two 4-step ranges
229  *
230  * _id - LDO id name string
231  * n_volt - number of votages available
232  * volt_ranges - array of regulator_linear_range
233  * vstep - voltage increase in each linear step in uV
234  * vreg - voltage select register
235  * vmask - voltage select mask
236  * ereg - enable register
237  * emask - enable mask
238  * odelay - off/on delay time in uS
239  * ecomask - eco mode mask
240  * ecoamp - eco mode load uppler limit in uA
241  */
242 #define HI6421_LDO_LINEAR_RANGE(_id, n_volt, volt_ranges, vreg, vmask,  \
243                                 ereg, emask, odelay, ecomask, ecoamp)   \
244         [HI6421_##_id] = {                                              \
245                 .desc = {                                               \
246                         .name           = #_id,                         \
247                         .ops            = &hi6421_ldo_linear_range_ops, \
248                         .type           = REGULATOR_VOLTAGE,            \
249                         .id             = HI6421_##_id,                 \
250                         .owner          = THIS_MODULE,                  \
251                         .n_voltages     = n_volt,                       \
252                         .linear_ranges  = volt_ranges,                  \
253                         .n_linear_ranges = ARRAY_SIZE(volt_ranges),     \
254                         .vsel_reg       = HI6421_REG_TO_BUS_ADDR(vreg), \
255                         .vsel_mask      = vmask,                        \
256                         .enable_reg     = HI6421_REG_TO_BUS_ADDR(ereg), \
257                         .enable_mask    = emask,                        \
258                         .enable_time    = HI6421_LDO_ENABLE_TIME,       \
259                         .off_on_delay   = odelay,                       \
260                 },                                                      \
261                 .mode_mask              = ecomask,                      \
262                 .eco_microamp           = ecoamp,                       \
263         }
264
265 /* HI6421 BUCK0/1/2 are linear voltage regulators at fixed uV_step
266  *
267  * _id - BUCK0/1/2 id name string
268  * vreg - voltage select register
269  * vmask - voltage select mask
270  * ereg - enable register
271  * emask - enable mask
272  * sleepmask - mask of sleep mode
273  * etime - enable time
274  * odelay - off/on delay time in uS
275  */
276 #define HI6421_BUCK012(_id, vreg, vmask, ereg, emask, sleepmask,        \
277                         etime, odelay)                                  \
278         [HI6421_##_id] = {                                              \
279                 .desc = {                                               \
280                         .name           = #_id,                         \
281                         .ops            = &hi6421_buck012_ops,          \
282                         .type           = REGULATOR_VOLTAGE,            \
283                         .id             = HI6421_##_id,                 \
284                         .owner          = THIS_MODULE,                  \
285                         .min_uV         = 700000,                       \
286                         .n_voltages     = 128,                          \
287                         .uV_step        = 7086,                         \
288                         .vsel_reg       = HI6421_REG_TO_BUS_ADDR(vreg), \
289                         .vsel_mask      = vmask,                        \
290                         .enable_reg     = HI6421_REG_TO_BUS_ADDR(ereg), \
291                         .enable_mask    = emask,                        \
292                         .enable_time    = etime,                        \
293                         .off_on_delay   = odelay,                       \
294                 },                                                      \
295                 .mode_mask              = sleepmask,                    \
296         }
297
298 /* HI6421 BUCK3/4/5 share similar configurations as LDOs, with exception
299  *  that it supports SLEEP mode, so has different .ops.
300  *
301  * _id - LDO id name string
302  * v_table - voltage table
303  * vreg - voltage select register
304  * vmask - voltage select mask
305  * ereg - enable register
306  * emask - enable mask
307  * odelay - off/on delay time in uS
308  * sleepmask - mask of sleep mode
309  */
310 #define HI6421_BUCK345(_id, v_table, vreg, vmask, ereg, emask,          \
311                         odelay, sleepmask)                              \
312         [HI6421_##_id] = {                                              \
313                 .desc = {                                               \
314                         .name           = #_id,                         \
315                         .ops            = &hi6421_buck345_ops,          \
316                         .type           = REGULATOR_VOLTAGE,            \
317                         .id             = HI6421_##_id,                 \
318                         .owner          = THIS_MODULE,                  \
319                         .n_voltages     = ARRAY_SIZE(v_table),          \
320                         .volt_table     = v_table,                      \
321                         .vsel_reg       = HI6421_REG_TO_BUS_ADDR(vreg), \
322                         .vsel_mask      = vmask,                        \
323                         .enable_reg     = HI6421_REG_TO_BUS_ADDR(ereg), \
324                         .enable_mask    = emask,                        \
325                         .enable_time    = HI6421_LDO_ENABLE_TIME,       \
326                         .off_on_delay   = odelay,                       \
327                 },                                                      \
328                 .mode_mask              = sleepmask,                    \
329         }
330
331 /* HI6421 regulator information */
332 static struct hi6421_regulator_info
333                 hi6421_regulator_info[HI6421_NUM_REGULATORS] = {
334         HI6421_LDO(LDO0, ldo_0_voltages, 0x20, 0x07, 0x20, 0x10,
335                    10000, 0x20, 8000),
336         HI6421_LDO_LINEAR(LDO1, 1700000, 4, 100000, 0x21, 0x03, 0x21, 0x10,
337                           10000, 0x20, 5000),
338         HI6421_LDO_LINEAR(LDO2, 1050000, 8, 50000, 0x22, 0x07, 0x22, 0x10,
339                           20000, 0x20, 8000),
340         HI6421_LDO_LINEAR(LDO3, 1050000, 8, 50000, 0x23, 0x07, 0x23, 0x10,
341                           20000, 0x20, 8000),
342         HI6421_LDO(LDO4, ldo_0_voltages, 0x24, 0x07, 0x24, 0x10,
343                    20000, 0x20, 8000),
344         HI6421_LDO(LDO5, ldo_0_voltages, 0x25, 0x07, 0x25, 0x10,
345                    20000, 0x20, 8000),
346         HI6421_LDO(LDO6, ldo_0_voltages, 0x26, 0x07, 0x26, 0x10,
347                    20000, 0x20, 8000),
348         HI6421_LDO(LDO7, ldo_0_voltages, 0x27, 0x07, 0x27, 0x10,
349                    20000, 0x20, 5000),
350         HI6421_LDO(LDO8, ldo_8_voltages, 0x28, 0x07, 0x28, 0x10,
351                    20000, 0x20, 8000),
352         HI6421_LDO(LDO9, ldo_0_voltages, 0x29, 0x07, 0x29, 0x10,
353                    40000, 0x20, 8000),
354         HI6421_LDO(LDO10, ldo_0_voltages, 0x2a, 0x07, 0x2a, 0x10,
355                    40000, 0x20, 8000),
356         HI6421_LDO(LDO11, ldo_0_voltages, 0x2b, 0x07, 0x2b, 0x10,
357                    40000, 0x20, 8000),
358         HI6421_LDO(LDO12, ldo_0_voltages, 0x2c, 0x07, 0x2c, 0x10,
359                    40000, 0x20, 8000),
360         HI6421_LDO(LDO13, ldo_0_voltages, 0x2d, 0x07, 0x2d, 0x10,
361                    40000, 0x20, 8000),
362         HI6421_LDO(LDO14, ldo_0_voltages, 0x2e, 0x07, 0x2e, 0x10,
363                    40000, 0x20, 8000),
364         HI6421_LDO(LDO15, ldo_8_voltages, 0x2f, 0x07, 0x2f, 0x10,
365                    40000, 0x20, 8000),
366         HI6421_LDO(LDO16, ldo_0_voltages, 0x30, 0x07, 0x30, 0x10,
367                    40000, 0x20, 8000),
368         HI6421_LDO(LDO17, ldo_0_voltages, 0x31, 0x07, 0x31, 0x10,
369                    40000, 0x20, 8000),
370         HI6421_LDO(LDO18, ldo_0_voltages, 0x32, 0x07, 0x32, 0x10,
371                    40000, 0x20, 8000),
372         HI6421_LDO(LDO19, ldo_0_voltages, 0x33, 0x07, 0x33, 0x10,
373                    40000, 0x20, 8000),
374         HI6421_LDO(LDO20, ldo_0_voltages, 0x34, 0x07, 0x34, 0x10,
375                    40000, 0x20, 8000),
376         HI6421_LDO_LINEAR_RANGE(LDOAUDIO, 8, ldo_audio_volt_range, 0x36,
377                                 0x70, 0x36, 0x01, 40000, 0x02, 5000),
378         HI6421_BUCK012(BUCK0, 0x0d, 0x7f, 0x0c, 0x01, 0x10, 400, 20000),
379         HI6421_BUCK012(BUCK1, 0x0f, 0x7f, 0x0e, 0x01, 0x10, 400, 20000),
380         HI6421_BUCK012(BUCK2, 0x11, 0x7f, 0x10, 0x01, 0x10, 350, 100),
381         HI6421_BUCK345(BUCK3, buck_3_voltages, 0x13, 0x07, 0x12, 0x01,
382                        20000, 0x10),
383         HI6421_BUCK345(BUCK4, buck_4_voltages, 0x15, 0x07, 0x14, 0x01,
384                        20000, 0x10),
385         HI6421_BUCK345(BUCK5, buck_5_voltages, 0x17, 0x07, 0x16, 0x01,
386                        20000, 0x10),
387 };
388
389 static int hi6421_regulator_enable(struct regulator_dev *rdev)
390 {
391         struct hi6421_regulator_pdata *pdata;
392
393         pdata = dev_get_drvdata(rdev->dev.parent);
394         /* hi6421 spec requires regulator enablement must be serialized:
395          *  - Because when BUCK, LDO switching from off to on, it will have
396          *    a huge instantaneous current; so you can not turn on two or
397          *    more LDO or BUCKs simultaneously, or it may burn the chip.
398          */
399         mutex_lock(&pdata->lock);
400
401         /* call regulator regmap helper */
402         regulator_enable_regmap(rdev);
403
404         mutex_unlock(&pdata->lock);
405         return 0;
406 }
407
408 static unsigned int hi6421_regulator_ldo_get_mode(struct regulator_dev *rdev)
409 {
410         struct hi6421_regulator_info *info = rdev_get_drvdata(rdev);
411         u32 reg_val;
412
413         regmap_read(rdev->regmap, rdev->desc->enable_reg, &reg_val);
414         if (reg_val & info->mode_mask)
415                 return REGULATOR_MODE_IDLE;
416
417         return REGULATOR_MODE_NORMAL;
418 }
419
420 static unsigned int hi6421_regulator_buck_get_mode(struct regulator_dev *rdev)
421 {
422         struct hi6421_regulator_info *info = rdev_get_drvdata(rdev);
423         u32 reg_val;
424
425         regmap_read(rdev->regmap, rdev->desc->enable_reg, &reg_val);
426         if (reg_val & info->mode_mask)
427                 return REGULATOR_MODE_STANDBY;
428
429         return REGULATOR_MODE_NORMAL;
430 }
431
432 static int hi6421_regulator_ldo_set_mode(struct regulator_dev *rdev,
433                                                 unsigned int mode)
434 {
435         struct hi6421_regulator_info *info = rdev_get_drvdata(rdev);
436         u32 new_mode;
437
438         switch (mode) {
439         case REGULATOR_MODE_NORMAL:
440                 new_mode = 0;
441                 break;
442         case REGULATOR_MODE_IDLE:
443                 new_mode = info->mode_mask;
444                 break;
445         default:
446                 return -EINVAL;
447         }
448
449         /* set mode */
450         regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
451                            info->mode_mask, new_mode);
452
453         return 0;
454 }
455
456 static int hi6421_regulator_buck_set_mode(struct regulator_dev *rdev,
457                                                 unsigned int mode)
458 {
459         struct hi6421_regulator_info *info = rdev_get_drvdata(rdev);
460         u32 new_mode;
461
462         switch (mode) {
463         case REGULATOR_MODE_NORMAL:
464                 new_mode = 0;
465                 break;
466         case REGULATOR_MODE_STANDBY:
467                 new_mode = info->mode_mask;
468                 break;
469         default:
470                 return -EINVAL;
471         }
472
473         /* set mode */
474         regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
475                            info->mode_mask, new_mode);
476
477         return 0;
478 }
479
480 static unsigned int
481 hi6421_regulator_ldo_get_optimum_mode(struct regulator_dev *rdev,
482                         int input_uV, int output_uV, int load_uA)
483 {
484         struct hi6421_regulator_info *info = rdev_get_drvdata(rdev);
485
486         if (load_uA > info->eco_microamp)
487                 return REGULATOR_MODE_NORMAL;
488
489         return REGULATOR_MODE_IDLE;
490 }
491
492 static const struct regulator_ops hi6421_ldo_ops = {
493         .is_enabled = regulator_is_enabled_regmap,
494         .enable = hi6421_regulator_enable,
495         .disable = regulator_disable_regmap,
496         .list_voltage = regulator_list_voltage_table,
497         .map_voltage = regulator_map_voltage_ascend,
498         .get_voltage_sel = regulator_get_voltage_sel_regmap,
499         .set_voltage_sel = regulator_set_voltage_sel_regmap,
500         .get_mode = hi6421_regulator_ldo_get_mode,
501         .set_mode = hi6421_regulator_ldo_set_mode,
502         .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode,
503 };
504
505 static const struct regulator_ops hi6421_ldo_linear_ops = {
506         .is_enabled = regulator_is_enabled_regmap,
507         .enable = hi6421_regulator_enable,
508         .disable = regulator_disable_regmap,
509         .list_voltage = regulator_list_voltage_linear,
510         .map_voltage = regulator_map_voltage_linear,
511         .get_voltage_sel = regulator_get_voltage_sel_regmap,
512         .set_voltage_sel = regulator_set_voltage_sel_regmap,
513         .get_mode = hi6421_regulator_ldo_get_mode,
514         .set_mode = hi6421_regulator_ldo_set_mode,
515         .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode,
516 };
517
518 static const struct regulator_ops hi6421_ldo_linear_range_ops = {
519         .is_enabled = regulator_is_enabled_regmap,
520         .enable = hi6421_regulator_enable,
521         .disable = regulator_disable_regmap,
522         .list_voltage = regulator_list_voltage_linear_range,
523         .map_voltage = regulator_map_voltage_linear_range,
524         .get_voltage_sel = regulator_get_voltage_sel_regmap,
525         .set_voltage_sel = regulator_set_voltage_sel_regmap,
526         .get_mode = hi6421_regulator_ldo_get_mode,
527         .set_mode = hi6421_regulator_ldo_set_mode,
528         .get_optimum_mode = hi6421_regulator_ldo_get_optimum_mode,
529 };
530
531 static const struct regulator_ops hi6421_buck012_ops = {
532         .is_enabled = regulator_is_enabled_regmap,
533         .enable = hi6421_regulator_enable,
534         .disable = regulator_disable_regmap,
535         .list_voltage = regulator_list_voltage_linear,
536         .map_voltage = regulator_map_voltage_linear,
537         .get_voltage_sel = regulator_get_voltage_sel_regmap,
538         .set_voltage_sel = regulator_set_voltage_sel_regmap,
539         .get_mode = hi6421_regulator_buck_get_mode,
540         .set_mode = hi6421_regulator_buck_set_mode,
541 };
542
543 static const struct regulator_ops hi6421_buck345_ops = {
544         .is_enabled = regulator_is_enabled_regmap,
545         .enable = hi6421_regulator_enable,
546         .disable = regulator_disable_regmap,
547         .list_voltage = regulator_list_voltage_table,
548         .map_voltage = regulator_map_voltage_ascend,
549         .get_voltage_sel = regulator_get_voltage_sel_regmap,
550         .set_voltage_sel = regulator_set_voltage_sel_regmap,
551         .get_mode = hi6421_regulator_buck_get_mode,
552         .set_mode = hi6421_regulator_buck_set_mode,
553 };
554
555 static int hi6421_regulator_register(struct platform_device *pdev,
556                                      struct regmap *rmap,
557                                      struct regulator_init_data *init_data,
558                                      int id, struct device_node *np)
559 {
560         struct hi6421_regulator_info *info = NULL;
561         struct regulator_config config = { };
562         struct regulator_dev *rdev;
563
564         /* assign per-regulator data */
565         info = &hi6421_regulator_info[id];
566
567         config.dev = &pdev->dev;
568         config.init_data = init_data;
569         config.driver_data = info;
570         config.regmap = rmap;
571         config.of_node = np;
572
573         /* register regulator with framework */
574         rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
575         if (IS_ERR(rdev)) {
576                 dev_err(&pdev->dev, "failed to register regulator %s\n",
577                         info->desc.name);
578                 return PTR_ERR(rdev);
579         }
580
581         return 0;
582 }
583
584 static int hi6421_regulator_probe(struct platform_device *pdev)
585 {
586         struct device *dev = &pdev->dev;
587         struct device_node *np;
588         struct hi6421_pmic *pmic;
589         struct hi6421_regulator_pdata *pdata;
590         int i, ret = 0;
591
592         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
593         if (!pdata)
594                 return -ENOMEM;
595         mutex_init(&pdata->lock);
596         platform_set_drvdata(pdev, pdata);
597
598         np = of_get_child_by_name(dev->parent->of_node, "regulators");
599         if (!np)
600                 return -ENODEV;
601
602         ret = of_regulator_match(dev, np,
603                                  hi6421_regulator_match,
604                                  ARRAY_SIZE(hi6421_regulator_match));
605         of_node_put(np);
606         if (ret < 0) {
607                 dev_err(dev, "Error parsing regulator init data: %d\n", ret);
608                 return ret;
609         }
610
611         pmic = dev_get_drvdata(dev->parent);
612
613         for (i = 0; i < ARRAY_SIZE(hi6421_regulator_info); i++) {
614                 ret = hi6421_regulator_register(pdev, pmic->regmap,
615                         hi6421_regulator_match[i].init_data, i,
616                         hi6421_regulator_match[i].of_node);
617                 if (ret)
618                         return ret;
619         }
620
621         return 0;
622 }
623
624 static const struct platform_device_id hi6421_regulator_table[] = {
625         { .name = "hi6421-regulator" },
626         {},
627 };
628 MODULE_DEVICE_TABLE(platform, hi6421_regulator_table);
629
630 static struct platform_driver hi6421_regulator_driver = {
631         .id_table = hi6421_regulator_table,
632         .driver = {
633                 .name   = "hi6421-regulator",
634         },
635         .probe  = hi6421_regulator_probe,
636 };
637 module_platform_driver(hi6421_regulator_driver);
638
639 MODULE_AUTHOR("Guodong Xu <guodong.xu@linaro.org>");
640 MODULE_DESCRIPTION("Hi6421 regulator driver");
641 MODULE_LICENSE("GPL v2");