1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | // |
3 | // da9052-regulator.c: Regulator driver for DA9052 |
4 | // |
5 | // Copyright(c) 2011 Dialog Semiconductor Ltd. |
6 | // |
7 | // Author: David Dajun Chen <dchen@diasemi.com> |
8 | |
9 | #include <linux/module.h> |
10 | #include <linux/moduleparam.h> |
11 | #include <linux/init.h> |
12 | #include <linux/err.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/regulator/driver.h> |
15 | #include <linux/regulator/machine.h> |
16 | #include <linux/of.h> |
17 | #include <linux/regulator/of_regulator.h> |
18 | |
19 | #include <linux/mfd/da9052/da9052.h> |
20 | #include <linux/mfd/da9052/reg.h> |
21 | #include <linux/mfd/da9052/pdata.h> |
22 | |
23 | /* Buck step size */ |
24 | #define DA9052_BUCK_PERI_3uV_STEP 100000 |
25 | #define DA9052_BUCK_PERI_REG_MAP_UPTO_3uV 24 |
26 | #define DA9052_CONST_3uV 3000000 |
27 | |
28 | #define DA9052_MIN_UA 0 |
29 | #define DA9052_MAX_UA 3 |
30 | #define DA9052_CURRENT_RANGE 4 |
31 | |
32 | /* Bit masks */ |
33 | #define DA9052_BUCK_ILIM_MASK_EVEN 0x0c |
34 | #define DA9052_BUCK_ILIM_MASK_ODD 0xc0 |
35 | |
36 | /* DA9052 REGULATOR IDs */ |
37 | #define DA9052_ID_BUCK1 0 |
38 | #define DA9052_ID_BUCK2 1 |
39 | #define DA9052_ID_BUCK3 2 |
40 | #define DA9052_ID_BUCK4 3 |
41 | #define DA9052_ID_LDO1 4 |
42 | #define DA9052_ID_LDO2 5 |
43 | #define DA9052_ID_LDO3 6 |
44 | #define DA9052_ID_LDO4 7 |
45 | #define DA9052_ID_LDO5 8 |
46 | #define DA9052_ID_LDO6 9 |
47 | #define DA9052_ID_LDO7 10 |
48 | #define DA9052_ID_LDO8 11 |
49 | #define DA9052_ID_LDO9 12 |
50 | #define DA9052_ID_LDO10 13 |
51 | |
52 | static const u32 da9052_current_limits[3][4] = { |
53 | {700000, 800000, 1000000, 1200000}, /* DA9052-BC BUCKs */ |
54 | {1600000, 2000000, 2400000, 3000000}, /* DA9053-AA/Bx BUCK-CORE */ |
55 | {800000, 1000000, 1200000, 1500000}, /* DA9053-AA/Bx BUCK-PRO, |
56 | * BUCK-MEM and BUCK-PERI |
57 | */ |
58 | }; |
59 | |
60 | struct da9052_regulator_info { |
61 | struct regulator_desc reg_desc; |
62 | int step_uV; |
63 | int min_uV; |
64 | int max_uV; |
65 | unsigned char activate_bit; |
66 | }; |
67 | |
68 | struct da9052_regulator { |
69 | struct da9052 *da9052; |
70 | struct da9052_regulator_info *info; |
71 | struct regulator_dev *rdev; |
72 | }; |
73 | |
74 | static int verify_range(struct da9052_regulator_info *info, |
75 | int min_uV, int max_uV) |
76 | { |
77 | if (min_uV > info->max_uV || max_uV < info->min_uV) |
78 | return -EINVAL; |
79 | |
80 | return 0; |
81 | } |
82 | |
83 | static int da9052_dcdc_get_current_limit(struct regulator_dev *rdev) |
84 | { |
85 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
86 | int offset = rdev_get_id(rdev); |
87 | int ret, row = 2; |
88 | |
89 | ret = da9052_reg_read(da9052: regulator->da9052, DA9052_BUCKA_REG + offset/2); |
90 | if (ret < 0) |
91 | return ret; |
92 | |
93 | /* Determine the even or odd position of the buck current limit |
94 | * register field |
95 | */ |
96 | if (offset % 2 == 0) |
97 | ret = (ret & DA9052_BUCK_ILIM_MASK_EVEN) >> 2; |
98 | else |
99 | ret = (ret & DA9052_BUCK_ILIM_MASK_ODD) >> 6; |
100 | |
101 | /* Select the appropriate current limit range */ |
102 | if (regulator->da9052->chip_id == DA9052) |
103 | row = 0; |
104 | else if (offset == 0) |
105 | row = 1; |
106 | |
107 | return da9052_current_limits[row][ret]; |
108 | } |
109 | |
110 | static int da9052_dcdc_set_current_limit(struct regulator_dev *rdev, int min_uA, |
111 | int max_uA) |
112 | { |
113 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
114 | int offset = rdev_get_id(rdev); |
115 | int reg_val = 0; |
116 | int i, row = 2; |
117 | |
118 | /* Select the appropriate current limit range */ |
119 | if (regulator->da9052->chip_id == DA9052) |
120 | row = 0; |
121 | else if (offset == 0) |
122 | row = 1; |
123 | |
124 | for (i = DA9052_CURRENT_RANGE - 1; i >= 0; i--) { |
125 | if ((min_uA <= da9052_current_limits[row][i]) && |
126 | (da9052_current_limits[row][i] <= max_uA)) { |
127 | reg_val = i; |
128 | break; |
129 | } |
130 | } |
131 | |
132 | if (i < 0) |
133 | return -EINVAL; |
134 | |
135 | /* Determine the even or odd position of the buck current limit |
136 | * register field |
137 | */ |
138 | if (offset % 2 == 0) |
139 | return da9052_reg_update(da9052: regulator->da9052, |
140 | DA9052_BUCKA_REG + offset/2, |
141 | DA9052_BUCK_ILIM_MASK_EVEN, |
142 | reg_val: reg_val << 2); |
143 | else |
144 | return da9052_reg_update(da9052: regulator->da9052, |
145 | DA9052_BUCKA_REG + offset/2, |
146 | DA9052_BUCK_ILIM_MASK_ODD, |
147 | reg_val: reg_val << 6); |
148 | } |
149 | |
150 | static int da9052_list_voltage(struct regulator_dev *rdev, |
151 | unsigned int selector) |
152 | { |
153 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
154 | struct da9052_regulator_info *info = regulator->info; |
155 | int id = rdev_get_id(rdev); |
156 | int volt_uV; |
157 | |
158 | if ((id == DA9052_ID_BUCK4) && (regulator->da9052->chip_id == DA9052) |
159 | && (selector >= DA9052_BUCK_PERI_REG_MAP_UPTO_3uV)) { |
160 | volt_uV = ((DA9052_BUCK_PERI_REG_MAP_UPTO_3uV * info->step_uV) |
161 | + info->min_uV); |
162 | volt_uV += (selector - DA9052_BUCK_PERI_REG_MAP_UPTO_3uV) |
163 | * (DA9052_BUCK_PERI_3uV_STEP); |
164 | } else { |
165 | volt_uV = (selector * info->step_uV) + info->min_uV; |
166 | } |
167 | |
168 | if (volt_uV > info->max_uV) |
169 | return -EINVAL; |
170 | |
171 | return volt_uV; |
172 | } |
173 | |
174 | static int da9052_map_voltage(struct regulator_dev *rdev, |
175 | int min_uV, int max_uV) |
176 | { |
177 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
178 | struct da9052_regulator_info *info = regulator->info; |
179 | int id = rdev_get_id(rdev); |
180 | int ret, sel; |
181 | |
182 | ret = verify_range(info, min_uV, max_uV); |
183 | if (ret < 0) |
184 | return ret; |
185 | |
186 | if (min_uV < info->min_uV) |
187 | min_uV = info->min_uV; |
188 | |
189 | if ((id == DA9052_ID_BUCK4) && (regulator->da9052->chip_id == DA9052) |
190 | && (min_uV >= DA9052_CONST_3uV)) { |
191 | sel = DA9052_BUCK_PERI_REG_MAP_UPTO_3uV + |
192 | DIV_ROUND_UP(min_uV - DA9052_CONST_3uV, |
193 | DA9052_BUCK_PERI_3uV_STEP); |
194 | } else { |
195 | sel = DIV_ROUND_UP(min_uV - info->min_uV, info->step_uV); |
196 | } |
197 | |
198 | ret = da9052_list_voltage(rdev, selector: sel); |
199 | if (ret < 0) |
200 | return ret; |
201 | |
202 | return sel; |
203 | } |
204 | |
205 | static int da9052_regulator_set_voltage_sel(struct regulator_dev *rdev, |
206 | unsigned int selector) |
207 | { |
208 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
209 | struct da9052_regulator_info *info = regulator->info; |
210 | int id = rdev_get_id(rdev); |
211 | int ret; |
212 | |
213 | ret = da9052_reg_update(da9052: regulator->da9052, reg: rdev->desc->vsel_reg, |
214 | bit_mask: rdev->desc->vsel_mask, reg_val: selector); |
215 | if (ret < 0) |
216 | return ret; |
217 | |
218 | /* Some LDOs and DCDCs are DVC controlled which requires enabling of |
219 | * the activate bit to implment the changes on the output. |
220 | */ |
221 | switch (id) { |
222 | case DA9052_ID_BUCK1: |
223 | case DA9052_ID_BUCK2: |
224 | case DA9052_ID_BUCK3: |
225 | case DA9052_ID_LDO2: |
226 | case DA9052_ID_LDO3: |
227 | ret = da9052_reg_update(da9052: regulator->da9052, DA9052_SUPPLY_REG, |
228 | bit_mask: info->activate_bit, reg_val: info->activate_bit); |
229 | break; |
230 | } |
231 | |
232 | return ret; |
233 | } |
234 | |
235 | static int da9052_regulator_set_voltage_time_sel(struct regulator_dev *rdev, |
236 | unsigned int old_sel, |
237 | unsigned int new_sel) |
238 | { |
239 | struct da9052_regulator *regulator = rdev_get_drvdata(rdev); |
240 | struct da9052_regulator_info *info = regulator->info; |
241 | int id = rdev_get_id(rdev); |
242 | int ret = 0; |
243 | |
244 | /* The DVC controlled LDOs and DCDCs ramp with 6.25mV/µs after enabling |
245 | * the activate bit. |
246 | */ |
247 | switch (id) { |
248 | case DA9052_ID_BUCK1: |
249 | case DA9052_ID_BUCK2: |
250 | case DA9052_ID_BUCK3: |
251 | case DA9052_ID_LDO2: |
252 | case DA9052_ID_LDO3: |
253 | ret = DIV_ROUND_UP(abs(new_sel - old_sel) * info->step_uV, |
254 | 6250); |
255 | break; |
256 | } |
257 | |
258 | return ret; |
259 | } |
260 | |
261 | static const struct regulator_ops da9052_dcdc_ops = { |
262 | .get_current_limit = da9052_dcdc_get_current_limit, |
263 | .set_current_limit = da9052_dcdc_set_current_limit, |
264 | |
265 | .list_voltage = da9052_list_voltage, |
266 | .map_voltage = da9052_map_voltage, |
267 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
268 | .set_voltage_sel = da9052_regulator_set_voltage_sel, |
269 | .set_voltage_time_sel = da9052_regulator_set_voltage_time_sel, |
270 | .is_enabled = regulator_is_enabled_regmap, |
271 | .enable = regulator_enable_regmap, |
272 | .disable = regulator_disable_regmap, |
273 | }; |
274 | |
275 | static const struct regulator_ops da9052_ldo_ops = { |
276 | .list_voltage = da9052_list_voltage, |
277 | .map_voltage = da9052_map_voltage, |
278 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
279 | .set_voltage_sel = da9052_regulator_set_voltage_sel, |
280 | .set_voltage_time_sel = da9052_regulator_set_voltage_time_sel, |
281 | .is_enabled = regulator_is_enabled_regmap, |
282 | .enable = regulator_enable_regmap, |
283 | .disable = regulator_disable_regmap, |
284 | }; |
285 | |
286 | #define DA9052_LDO(_id, _name, step, min, max, sbits, ebits, abits) \ |
287 | {\ |
288 | .reg_desc = {\ |
289 | .name = #_name,\ |
290 | .of_match = of_match_ptr(#_name),\ |
291 | .regulators_node = of_match_ptr("regulators"),\ |
292 | .ops = &da9052_ldo_ops,\ |
293 | .type = REGULATOR_VOLTAGE,\ |
294 | .id = DA9052_ID_##_id,\ |
295 | .n_voltages = (max - min) / step + 1, \ |
296 | .owner = THIS_MODULE,\ |
297 | .vsel_reg = DA9052_BUCKCORE_REG + DA9052_ID_##_id, \ |
298 | .vsel_mask = (1 << (sbits)) - 1,\ |
299 | .enable_reg = DA9052_BUCKCORE_REG + DA9052_ID_##_id, \ |
300 | .enable_mask = 1 << (ebits),\ |
301 | },\ |
302 | .min_uV = (min) * 1000,\ |
303 | .max_uV = (max) * 1000,\ |
304 | .step_uV = (step) * 1000,\ |
305 | .activate_bit = (abits),\ |
306 | } |
307 | |
308 | #define DA9052_DCDC(_id, _name, step, min, max, sbits, ebits, abits) \ |
309 | {\ |
310 | .reg_desc = {\ |
311 | .name = #_name,\ |
312 | .of_match = of_match_ptr(#_name),\ |
313 | .regulators_node = of_match_ptr("regulators"),\ |
314 | .ops = &da9052_dcdc_ops,\ |
315 | .type = REGULATOR_VOLTAGE,\ |
316 | .id = DA9052_ID_##_id,\ |
317 | .n_voltages = (max - min) / step + 1, \ |
318 | .owner = THIS_MODULE,\ |
319 | .vsel_reg = DA9052_BUCKCORE_REG + DA9052_ID_##_id, \ |
320 | .vsel_mask = (1 << (sbits)) - 1,\ |
321 | .enable_reg = DA9052_BUCKCORE_REG + DA9052_ID_##_id, \ |
322 | .enable_mask = 1 << (ebits),\ |
323 | },\ |
324 | .min_uV = (min) * 1000,\ |
325 | .max_uV = (max) * 1000,\ |
326 | .step_uV = (step) * 1000,\ |
327 | .activate_bit = (abits),\ |
328 | } |
329 | |
330 | static struct da9052_regulator_info da9052_regulator_info[] = { |
331 | DA9052_DCDC(BUCK1, buck1, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBCOREGO), |
332 | DA9052_DCDC(BUCK2, buck2, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBPROGO), |
333 | DA9052_DCDC(BUCK3, buck3, 25, 950, 2525, 6, 6, DA9052_SUPPLY_VBMEMGO), |
334 | DA9052_DCDC(BUCK4, buck4, 50, 1800, 3600, 5, 6, 0), |
335 | DA9052_LDO(LDO1, ldo1, 50, 600, 1800, 5, 6, 0), |
336 | DA9052_LDO(LDO2, ldo2, 25, 600, 1800, 6, 6, DA9052_SUPPLY_VLDO2GO), |
337 | DA9052_LDO(LDO3, ldo3, 25, 1725, 3300, 6, 6, DA9052_SUPPLY_VLDO3GO), |
338 | DA9052_LDO(LDO4, ldo4, 25, 1725, 3300, 6, 6, 0), |
339 | DA9052_LDO(LDO5, ldo5, 50, 1200, 3600, 6, 6, 0), |
340 | DA9052_LDO(LDO6, ldo6, 50, 1200, 3600, 6, 6, 0), |
341 | DA9052_LDO(LDO7, ldo7, 50, 1200, 3600, 6, 6, 0), |
342 | DA9052_LDO(LDO8, ldo8, 50, 1200, 3600, 6, 6, 0), |
343 | DA9052_LDO(LDO9, ldo9, 50, 1250, 3650, 6, 6, 0), |
344 | DA9052_LDO(LDO10, ldo10, 50, 1200, 3600, 6, 6, 0), |
345 | }; |
346 | |
347 | static struct da9052_regulator_info da9053_regulator_info[] = { |
348 | DA9052_DCDC(BUCK1, buck1, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBCOREGO), |
349 | DA9052_DCDC(BUCK2, buck2, 25, 500, 2075, 6, 6, DA9052_SUPPLY_VBPROGO), |
350 | DA9052_DCDC(BUCK3, buck3, 25, 950, 2525, 6, 6, DA9052_SUPPLY_VBMEMGO), |
351 | DA9052_DCDC(BUCK4, buck4, 25, 950, 2525, 6, 6, 0), |
352 | DA9052_LDO(LDO1, ldo1, 50, 600, 1800, 5, 6, 0), |
353 | DA9052_LDO(LDO2, ldo2, 25, 600, 1800, 6, 6, DA9052_SUPPLY_VLDO2GO), |
354 | DA9052_LDO(LDO3, ldo3, 25, 1725, 3300, 6, 6, DA9052_SUPPLY_VLDO3GO), |
355 | DA9052_LDO(LDO4, ldo4, 25, 1725, 3300, 6, 6, 0), |
356 | DA9052_LDO(LDO5, ldo5, 50, 1200, 3600, 6, 6, 0), |
357 | DA9052_LDO(LDO6, ldo6, 50, 1200, 3600, 6, 6, 0), |
358 | DA9052_LDO(LDO7, ldo7, 50, 1200, 3600, 6, 6, 0), |
359 | DA9052_LDO(LDO8, ldo8, 50, 1200, 3600, 6, 6, 0), |
360 | DA9052_LDO(LDO9, ldo9, 50, 1250, 3650, 6, 6, 0), |
361 | DA9052_LDO(LDO10, ldo10, 50, 1200, 3600, 6, 6, 0), |
362 | }; |
363 | |
364 | static inline struct da9052_regulator_info *find_regulator_info(u8 chip_id, |
365 | int id) |
366 | { |
367 | struct da9052_regulator_info *info; |
368 | int i; |
369 | |
370 | switch (chip_id) { |
371 | case DA9052: |
372 | for (i = 0; i < ARRAY_SIZE(da9052_regulator_info); i++) { |
373 | info = &da9052_regulator_info[i]; |
374 | if (info->reg_desc.id == id) |
375 | return info; |
376 | } |
377 | break; |
378 | case DA9053_AA: |
379 | case DA9053_BA: |
380 | case DA9053_BB: |
381 | case DA9053_BC: |
382 | for (i = 0; i < ARRAY_SIZE(da9053_regulator_info); i++) { |
383 | info = &da9053_regulator_info[i]; |
384 | if (info->reg_desc.id == id) |
385 | return info; |
386 | } |
387 | break; |
388 | } |
389 | |
390 | return NULL; |
391 | } |
392 | |
393 | static int da9052_regulator_probe(struct platform_device *pdev) |
394 | { |
395 | const struct mfd_cell *cell = mfd_get_cell(pdev); |
396 | struct regulator_config config = { }; |
397 | struct da9052_regulator *regulator; |
398 | struct da9052 *da9052; |
399 | struct da9052_pdata *pdata; |
400 | |
401 | regulator = devm_kzalloc(dev: &pdev->dev, size: sizeof(struct da9052_regulator), |
402 | GFP_KERNEL); |
403 | if (!regulator) |
404 | return -ENOMEM; |
405 | |
406 | da9052 = dev_get_drvdata(dev: pdev->dev.parent); |
407 | pdata = dev_get_platdata(dev: da9052->dev); |
408 | regulator->da9052 = da9052; |
409 | |
410 | regulator->info = find_regulator_info(chip_id: regulator->da9052->chip_id, |
411 | id: cell->id); |
412 | if (regulator->info == NULL) { |
413 | dev_err(&pdev->dev, "invalid regulator ID specified\n" ); |
414 | return -EINVAL; |
415 | } |
416 | |
417 | config.dev = da9052->dev; |
418 | config.driver_data = regulator; |
419 | config.regmap = da9052->regmap; |
420 | if (pdata) |
421 | config.init_data = pdata->regulators[cell->id]; |
422 | |
423 | regulator->rdev = devm_regulator_register(dev: &pdev->dev, |
424 | regulator_desc: ®ulator->info->reg_desc, |
425 | config: &config); |
426 | if (IS_ERR(ptr: regulator->rdev)) { |
427 | dev_err(&pdev->dev, "failed to register regulator %s\n" , |
428 | regulator->info->reg_desc.name); |
429 | return PTR_ERR(ptr: regulator->rdev); |
430 | } |
431 | |
432 | platform_set_drvdata(pdev, data: regulator); |
433 | |
434 | return 0; |
435 | } |
436 | |
437 | static struct platform_driver da9052_regulator_driver = { |
438 | .probe = da9052_regulator_probe, |
439 | .driver = { |
440 | .name = "da9052-regulator" , |
441 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
442 | }, |
443 | }; |
444 | |
445 | static int __init da9052_regulator_init(void) |
446 | { |
447 | return platform_driver_register(&da9052_regulator_driver); |
448 | } |
449 | subsys_initcall(da9052_regulator_init); |
450 | |
451 | static void __exit da9052_regulator_exit(void) |
452 | { |
453 | platform_driver_unregister(&da9052_regulator_driver); |
454 | } |
455 | module_exit(da9052_regulator_exit); |
456 | |
457 | MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>" ); |
458 | MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9052 PMIC" ); |
459 | MODULE_LICENSE("GPL" ); |
460 | MODULE_ALIAS("platform:da9052-regulator" ); |
461 | |