1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // Regulator driver for DA9055 PMIC
4 //
5 // Copyright(c) 2012 Dialog Semiconductor Ltd.
6 //
7 // Author: David Dajun Chen <dchen@diasemi.com>
8
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/err.h>
12 #include <linux/gpio/consumer.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/da9055/core.h>
20 #include <linux/mfd/da9055/reg.h>
21 #include <linux/mfd/da9055/pdata.h>
22
23 #define DA9055_MIN_UA 0
24 #define DA9055_MAX_UA 3
25
26 #define DA9055_LDO_MODE_SYNC 0
27 #define DA9055_LDO_MODE_SLEEP 1
28
29 #define DA9055_BUCK_MODE_SLEEP 1
30 #define DA9055_BUCK_MODE_SYNC 2
31 #define DA9055_BUCK_MODE_AUTO 3
32
33 /* DA9055 REGULATOR IDs */
34 #define DA9055_ID_BUCK1 0
35 #define DA9055_ID_BUCK2 1
36 #define DA9055_ID_LDO1 2
37 #define DA9055_ID_LDO2 3
38 #define DA9055_ID_LDO3 4
39 #define DA9055_ID_LDO4 5
40 #define DA9055_ID_LDO5 6
41 #define DA9055_ID_LDO6 7
42
43 /* DA9055 BUCK current limit */
44 static const unsigned int da9055_current_limits[] = {
45 500000, 600000, 700000, 800000
46 };
47
48 struct da9055_conf_reg {
49 int reg;
50 int sel_mask;
51 int en_mask;
52 };
53
54 struct da9055_volt_reg {
55 int reg_a;
56 int reg_b;
57 int sl_shift;
58 int v_mask;
59 };
60
61 struct da9055_mode_reg {
62 int reg;
63 int mask;
64 int shift;
65 };
66
67 struct da9055_regulator_info {
68 struct regulator_desc reg_desc;
69 struct da9055_conf_reg conf;
70 struct da9055_volt_reg volt;
71 struct da9055_mode_reg mode;
72 };
73
74 struct da9055_regulator {
75 struct da9055 *da9055;
76 const struct da9055_regulator_info *info;
77 struct regulator_dev *rdev;
78 enum gpio_select reg_rselect;
79 };
80
da9055_buck_get_mode(struct regulator_dev * rdev)81 static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev)
82 {
83 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
84 const struct da9055_regulator_info *info = regulator->info;
85 int ret, mode = 0;
86
87 ret = da9055_reg_read(regulator->da9055, info->mode.reg);
88 if (ret < 0)
89 return ret;
90
91 switch ((ret & info->mode.mask) >> info->mode.shift) {
92 case DA9055_BUCK_MODE_SYNC:
93 mode = REGULATOR_MODE_FAST;
94 break;
95 case DA9055_BUCK_MODE_AUTO:
96 mode = REGULATOR_MODE_NORMAL;
97 break;
98 case DA9055_BUCK_MODE_SLEEP:
99 mode = REGULATOR_MODE_STANDBY;
100 break;
101 }
102
103 return mode;
104 }
105
da9055_buck_set_mode(struct regulator_dev * rdev,unsigned int mode)106 static int da9055_buck_set_mode(struct regulator_dev *rdev,
107 unsigned int mode)
108 {
109 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
110 const struct da9055_regulator_info *info = regulator->info;
111 int val = 0;
112
113 switch (mode) {
114 case REGULATOR_MODE_FAST:
115 val = DA9055_BUCK_MODE_SYNC << info->mode.shift;
116 break;
117 case REGULATOR_MODE_NORMAL:
118 val = DA9055_BUCK_MODE_AUTO << info->mode.shift;
119 break;
120 case REGULATOR_MODE_STANDBY:
121 val = DA9055_BUCK_MODE_SLEEP << info->mode.shift;
122 break;
123 }
124
125 return da9055_reg_update(regulator->da9055, info->mode.reg,
126 info->mode.mask, val);
127 }
128
da9055_ldo_get_mode(struct regulator_dev * rdev)129 static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev)
130 {
131 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
132 const struct da9055_regulator_info *info = regulator->info;
133 int ret;
134
135 ret = da9055_reg_read(regulator->da9055, info->volt.reg_b);
136 if (ret < 0)
137 return ret;
138
139 if (ret >> info->volt.sl_shift)
140 return REGULATOR_MODE_STANDBY;
141 else
142 return REGULATOR_MODE_NORMAL;
143 }
144
da9055_ldo_set_mode(struct regulator_dev * rdev,unsigned int mode)145 static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
146 {
147 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
148 const struct da9055_regulator_info *info = regulator->info;
149 struct da9055_volt_reg volt = info->volt;
150 int val = 0;
151
152 switch (mode) {
153 case REGULATOR_MODE_NORMAL:
154 case REGULATOR_MODE_FAST:
155 val = DA9055_LDO_MODE_SYNC;
156 break;
157 case REGULATOR_MODE_STANDBY:
158 val = DA9055_LDO_MODE_SLEEP;
159 break;
160 }
161
162 return da9055_reg_update(regulator->da9055, volt.reg_b,
163 1 << volt.sl_shift,
164 val << volt.sl_shift);
165 }
166
da9055_regulator_get_voltage_sel(struct regulator_dev * rdev)167 static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev)
168 {
169 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
170 const struct da9055_regulator_info *info = regulator->info;
171 struct da9055_volt_reg volt = info->volt;
172 int ret, sel;
173
174 /*
175 * There are two voltage register set A & B for voltage ramping but
176 * either one of then can be active therefore we first determine
177 * the active register set.
178 */
179 ret = da9055_reg_read(regulator->da9055, info->conf.reg);
180 if (ret < 0)
181 return ret;
182
183 ret &= info->conf.sel_mask;
184
185 /* Get the voltage for the active register set A/B */
186 if (ret == DA9055_REGUALTOR_SET_A)
187 ret = da9055_reg_read(regulator->da9055, volt.reg_a);
188 else
189 ret = da9055_reg_read(regulator->da9055, volt.reg_b);
190
191 if (ret < 0)
192 return ret;
193
194 sel = (ret & volt.v_mask);
195 return sel;
196 }
197
da9055_regulator_set_voltage_sel(struct regulator_dev * rdev,unsigned int selector)198 static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev,
199 unsigned int selector)
200 {
201 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
202 const struct da9055_regulator_info *info = regulator->info;
203 int ret;
204
205 /*
206 * Regulator register set A/B is not selected through GPIO therefore
207 * we use default register set A for voltage ramping.
208 */
209 if (regulator->reg_rselect == NO_GPIO) {
210 /* Select register set A */
211 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
212 info->conf.sel_mask, DA9055_SEL_REG_A);
213 if (ret < 0)
214 return ret;
215
216 /* Set the voltage */
217 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
218 info->volt.v_mask, selector);
219 }
220
221 /*
222 * Here regulator register set A/B is selected through GPIO.
223 * Therefore we first determine the selected register set A/B and
224 * then set the desired voltage for that register set A/B.
225 */
226 ret = da9055_reg_read(regulator->da9055, info->conf.reg);
227 if (ret < 0)
228 return ret;
229
230 ret &= info->conf.sel_mask;
231
232 /* Set the voltage */
233 if (ret == DA9055_REGUALTOR_SET_A)
234 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
235 info->volt.v_mask, selector);
236 else
237 return da9055_reg_update(regulator->da9055, info->volt.reg_b,
238 info->volt.v_mask, selector);
239 }
240
da9055_regulator_set_suspend_voltage(struct regulator_dev * rdev,int uV)241 static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev,
242 int uV)
243 {
244 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
245 const struct da9055_regulator_info *info = regulator->info;
246 int ret;
247
248 /* Select register set B for suspend voltage ramping. */
249 if (regulator->reg_rselect == NO_GPIO) {
250 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
251 info->conf.sel_mask, DA9055_SEL_REG_B);
252 if (ret < 0)
253 return ret;
254 }
255
256 ret = regulator_map_voltage_linear(rdev, uV, uV);
257 if (ret < 0)
258 return ret;
259
260 return da9055_reg_update(regulator->da9055, info->volt.reg_b,
261 info->volt.v_mask, ret);
262 }
263
da9055_suspend_enable(struct regulator_dev * rdev)264 static int da9055_suspend_enable(struct regulator_dev *rdev)
265 {
266 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
267 const struct da9055_regulator_info *info = regulator->info;
268
269 /* Select register set B for voltage ramping. */
270 if (regulator->reg_rselect == NO_GPIO)
271 return da9055_reg_update(regulator->da9055, info->conf.reg,
272 info->conf.sel_mask, DA9055_SEL_REG_B);
273 else
274 return 0;
275 }
276
da9055_suspend_disable(struct regulator_dev * rdev)277 static int da9055_suspend_disable(struct regulator_dev *rdev)
278 {
279 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
280 const struct da9055_regulator_info *info = regulator->info;
281
282 /* Diselect register set B. */
283 if (regulator->reg_rselect == NO_GPIO)
284 return da9055_reg_update(regulator->da9055, info->conf.reg,
285 info->conf.sel_mask, DA9055_SEL_REG_A);
286 else
287 return 0;
288 }
289
290 static const struct regulator_ops da9055_buck_ops = {
291 .get_mode = da9055_buck_get_mode,
292 .set_mode = da9055_buck_set_mode,
293
294 .get_current_limit = regulator_get_current_limit_regmap,
295 .set_current_limit = regulator_set_current_limit_regmap,
296
297 .get_voltage_sel = da9055_regulator_get_voltage_sel,
298 .set_voltage_sel = da9055_regulator_set_voltage_sel,
299 .list_voltage = regulator_list_voltage_linear,
300 .map_voltage = regulator_map_voltage_linear,
301 .is_enabled = regulator_is_enabled_regmap,
302 .enable = regulator_enable_regmap,
303 .disable = regulator_disable_regmap,
304
305 .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
306 .set_suspend_enable = da9055_suspend_enable,
307 .set_suspend_disable = da9055_suspend_disable,
308 .set_suspend_mode = da9055_buck_set_mode,
309 };
310
311 static const struct regulator_ops da9055_ldo_ops = {
312 .get_mode = da9055_ldo_get_mode,
313 .set_mode = da9055_ldo_set_mode,
314
315 .get_voltage_sel = da9055_regulator_get_voltage_sel,
316 .set_voltage_sel = da9055_regulator_set_voltage_sel,
317 .list_voltage = regulator_list_voltage_linear,
318 .map_voltage = regulator_map_voltage_linear,
319 .is_enabled = regulator_is_enabled_regmap,
320 .enable = regulator_enable_regmap,
321 .disable = regulator_disable_regmap,
322
323 .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
324 .set_suspend_enable = da9055_suspend_enable,
325 .set_suspend_disable = da9055_suspend_disable,
326 .set_suspend_mode = da9055_ldo_set_mode,
327
328 };
329
330 #define DA9055_LDO(_id, step, min, max, vbits, voffset) \
331 {\
332 .reg_desc = {\
333 .name = #_id,\
334 .of_match = of_match_ptr(#_id),\
335 .regulators_node = of_match_ptr("regulators"),\
336 .ops = &da9055_ldo_ops,\
337 .type = REGULATOR_VOLTAGE,\
338 .id = DA9055_ID_##_id,\
339 .n_voltages = (max - min) / step + 1 + (voffset), \
340 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
341 .enable_mask = 1, \
342 .min_uV = (min) * 1000,\
343 .uV_step = (step) * 1000,\
344 .linear_min_sel = (voffset),\
345 .owner = THIS_MODULE,\
346 },\
347 .conf = {\
348 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
349 .sel_mask = (1 << 4),\
350 .en_mask = 1,\
351 },\
352 .volt = {\
353 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
354 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
355 .sl_shift = 7,\
356 .v_mask = (1 << (vbits)) - 1,\
357 },\
358 }
359
360 #define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \
361 {\
362 .reg_desc = {\
363 .name = #_id,\
364 .of_match = of_match_ptr(#_id),\
365 .regulators_node = of_match_ptr("regulators"),\
366 .ops = &da9055_buck_ops,\
367 .type = REGULATOR_VOLTAGE,\
368 .id = DA9055_ID_##_id,\
369 .n_voltages = (max - min) / step + 1 + (voffset), \
370 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
371 .enable_mask = 1,\
372 .min_uV = (min) * 1000,\
373 .uV_step = (step) * 1000,\
374 .linear_min_sel = (voffset),\
375 .owner = THIS_MODULE,\
376 .curr_table = da9055_current_limits,\
377 .n_current_limits = ARRAY_SIZE(da9055_current_limits),\
378 .csel_reg = DA9055_REG_BUCK_LIM,\
379 .csel_mask = (mbits),\
380 },\
381 .conf = {\
382 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
383 .sel_mask = (1 << 4),\
384 .en_mask = 1,\
385 },\
386 .volt = {\
387 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
388 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
389 .sl_shift = 7,\
390 .v_mask = (1 << (vbits)) - 1,\
391 },\
392 .mode = {\
393 .reg = DA9055_REG_BCORE_MODE,\
394 .mask = (mbits),\
395 .shift = (sbits),\
396 },\
397 }
398
399 static const struct da9055_regulator_info da9055_regulator_info[] = {
400 DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2),
401 DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0),
402 DA9055_LDO(LDO1, 50, 900, 3300, 6, 2),
403 DA9055_LDO(LDO2, 50, 900, 3300, 6, 3),
404 DA9055_LDO(LDO3, 50, 900, 3300, 6, 2),
405 DA9055_LDO(LDO4, 50, 900, 3300, 6, 2),
406 DA9055_LDO(LDO5, 50, 900, 2750, 6, 2),
407 DA9055_LDO(LDO6, 20, 900, 3300, 7, 0),
408 };
409
410 /*
411 * Configures regulator to be controlled either through GPIO 1 or 2.
412 * GPIO can control regulator state and/or select the regulator register
413 * set A/B for voltage ramping.
414 */
da9055_gpio_init(struct device * dev,struct da9055_regulator * regulator,struct regulator_config * config,struct da9055_pdata * pdata,int id)415 static int da9055_gpio_init(struct device *dev,
416 struct da9055_regulator *regulator,
417 struct regulator_config *config,
418 struct da9055_pdata *pdata, int id)
419 {
420 const struct da9055_regulator_info *info = regulator->info;
421 struct gpio_desc *ren;
422 struct gpio_desc *ena;
423 struct gpio_desc *rsel;
424 int ret = 0;
425
426 /* Look for "regulator-enable-gpios" GPIOs in the regulator node */
427 ren = devm_gpiod_get_optional(dev, "regulator-enable", GPIOD_IN);
428 if (IS_ERR(ren))
429 return PTR_ERR(ren);
430
431 if (ren) {
432 /* This GPIO is not optional at this point */
433 ena = devm_gpiod_get(dev, "enable", GPIOD_OUT_HIGH);
434 if (IS_ERR(ena))
435 return PTR_ERR(ena);
436
437 config->ena_gpiod = ena;
438
439 /*
440 * GPI pin is muxed with regulator to control the
441 * regulator state.
442 */
443 gpiod_set_consumer_name(ren, "DA9055 ren GPI");
444
445 /*
446 * Let the regulator know that its state is controlled
447 * through GPI.
448 */
449 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
450 DA9055_E_GPI_MASK,
451 pdata->reg_ren[id]
452 << DA9055_E_GPI_SHIFT);
453 if (ret < 0)
454 return ret;
455 }
456
457 /* Look for "regulator-select-gpios" GPIOs in the regulator node */
458 rsel = devm_gpiod_get_optional(dev, "regulator-select", GPIOD_IN);
459 if (IS_ERR(rsel))
460 return PTR_ERR(rsel);
461
462 if (rsel) {
463 regulator->reg_rselect = pdata->reg_rsel[id];
464
465 /*
466 * GPI pin is muxed with regulator to select the
467 * regulator register set A/B for voltage ramping.
468 */
469 gpiod_set_consumer_name(rsel, "DA9055 rsel GPI");
470
471 /*
472 * Let the regulator know that its register set A/B
473 * will be selected through GPI for voltage ramping.
474 */
475 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
476 DA9055_V_GPI_MASK,
477 pdata->reg_rsel[id]
478 << DA9055_V_GPI_SHIFT);
479 }
480
481 return ret;
482 }
483
da9055_ldo5_6_oc_irq(int irq,void * data)484 static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data)
485 {
486 struct da9055_regulator *regulator = data;
487
488 regulator_notifier_call_chain(regulator->rdev,
489 REGULATOR_EVENT_OVER_CURRENT, NULL);
490
491 return IRQ_HANDLED;
492 }
493
find_regulator_info(int id)494 static inline const struct da9055_regulator_info *find_regulator_info(int id)
495 {
496 const struct da9055_regulator_info *info;
497 int i;
498
499 for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) {
500 info = &da9055_regulator_info[i];
501 if (info->reg_desc.id == id)
502 return info;
503 }
504
505 return NULL;
506 }
507
da9055_regulator_probe(struct platform_device * pdev)508 static int da9055_regulator_probe(struct platform_device *pdev)
509 {
510 struct regulator_config config = { };
511 struct da9055_regulator *regulator;
512 struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
513 struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
514 int ret, irq;
515
516 regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
517 GFP_KERNEL);
518 if (!regulator)
519 return -ENOMEM;
520
521 regulator->info = find_regulator_info(pdev->id);
522 if (regulator->info == NULL) {
523 dev_err(&pdev->dev, "invalid regulator ID specified\n");
524 return -EINVAL;
525 }
526
527 regulator->da9055 = da9055;
528 config.dev = da9055->dev;
529 config.driver_data = regulator;
530 config.regmap = da9055->regmap;
531
532 if (pdata)
533 config.init_data = pdata->regulators[pdev->id];
534
535 ret = da9055_gpio_init(&pdev->dev, regulator, &config, pdata, pdev->id);
536 if (ret < 0)
537 return ret;
538
539 regulator->rdev = devm_regulator_register(&pdev->dev,
540 ®ulator->info->reg_desc,
541 &config);
542 if (IS_ERR(regulator->rdev)) {
543 dev_err(&pdev->dev, "Failed to register regulator %s\n",
544 regulator->info->reg_desc.name);
545 return PTR_ERR(regulator->rdev);
546 }
547
548 /* Only LDO 5 and 6 has got the over current interrupt */
549 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) {
550 irq = platform_get_irq_byname(pdev, "REGULATOR");
551 if (irq < 0)
552 return irq;
553
554 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
555 da9055_ldo5_6_oc_irq,
556 IRQF_TRIGGER_HIGH |
557 IRQF_ONESHOT |
558 IRQF_PROBE_SHARED,
559 pdev->name, regulator);
560 if (ret != 0) {
561 if (ret != -EBUSY) {
562 dev_err(&pdev->dev,
563 "Failed to request Regulator IRQ %d: %d\n",
564 irq, ret);
565 return ret;
566 }
567 }
568 }
569
570 platform_set_drvdata(pdev, regulator);
571
572 return 0;
573 }
574
575 static struct platform_driver da9055_regulator_driver = {
576 .probe = da9055_regulator_probe,
577 .driver = {
578 .name = "da9055-regulator",
579 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
580 },
581 };
582
da9055_regulator_init(void)583 static int __init da9055_regulator_init(void)
584 {
585 return platform_driver_register(&da9055_regulator_driver);
586 }
587 subsys_initcall(da9055_regulator_init);
588
da9055_regulator_exit(void)589 static void __exit da9055_regulator_exit(void)
590 {
591 platform_driver_unregister(&da9055_regulator_driver);
592 }
593 module_exit(da9055_regulator_exit);
594
595 MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
596 MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
597 MODULE_LICENSE("GPL");
598 MODULE_ALIAS("platform:da9055-regulator");
599