Commit | Line | Data |
---|---|---|
87ca186f GX |
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> | |
87ca186f GX |
20 | #include <linux/platform_device.h> |
21 | #include <linux/of.h> | |
87ca186f GX |
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> | |
87ca186f GX |
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 | |
87ca186f | 38 | * @desc: regulator description |
87ca186f | 39 | * @mode_mask: ECO mode bitmask of LDOs; for BUCKs, this masks sleep |
97795e4d | 40 | * @eco_microamp: eco mode load upper limit (in uA), valid for LDOs only |
87ca186f GX |
41 | */ |
42 | struct hi6421_regulator_info { | |
87ca186f | 43 | struct regulator_desc desc; |
87ca186f GX |
44 | u8 mode_mask; |
45 | u32 eco_microamp; | |
87ca186f GX |
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 | |
5c5e417b | 167 | * ecoamp - eco mode load uppler limit in uA |
87ca186f GX |
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, \ | |
87ca186f GX |
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 | |
5c5e417b | 203 | * ecoamp - eco mode load uppler limit in uA |
87ca186f GX |
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, \ | |
87ca186f GX |
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 | |
5c5e417b | 240 | * ecoamp - eco mode load uppler limit in uA |
87ca186f GX |
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, \ | |
87ca186f GX |
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, \ | |
87ca186f GX |
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, \ | |
87ca186f GX |
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, ®_val); | |
414 | if (reg_val & info->mode_mask) | |
415 | return REGULATOR_MODE_IDLE; | |
ea62f4df GX |
416 | |
417 | return REGULATOR_MODE_NORMAL; | |
87ca186f GX |
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, ®_val); | |
426 | if (reg_val & info->mode_mask) | |
427 | return REGULATOR_MODE_STANDBY; | |
ea62f4df GX |
428 | |
429 | return REGULATOR_MODE_NORMAL; | |
87ca186f GX |
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 | ||
ea2f7321 BX |
480 | static unsigned int |
481 | hi6421_regulator_ldo_get_optimum_mode(struct regulator_dev *rdev, | |
87ca186f GX |
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; | |
ea62f4df GX |
488 | |
489 | return REGULATOR_MODE_IDLE; | |
87ca186f GX |
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 = { }; | |
8e820007 | 562 | struct regulator_dev *rdev; |
87ca186f GX |
563 | |
564 | /* assign per-regulator data */ | |
565 | info = &hi6421_regulator_info[id]; | |
87ca186f GX |
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 */ | |
8e820007 AL |
574 | rdev = devm_regulator_register(&pdev->dev, &info->desc, &config); |
575 | if (IS_ERR(rdev)) { | |
87ca186f GX |
576 | dev_err(&pdev->dev, "failed to register regulator %s\n", |
577 | info->desc.name); | |
8e820007 | 578 | return PTR_ERR(rdev); |
87ca186f GX |
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 | ||
a8ea49d7 GX |
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 | ||
87ca186f | 630 | static struct platform_driver hi6421_regulator_driver = { |
a8ea49d7 | 631 | .id_table = hi6421_regulator_table, |
87ca186f GX |
632 | .driver = { |
633 | .name = "hi6421-regulator", | |
87ca186f GX |
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"); |