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");
642