Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Maxim MAX77620 Regulator driver
4 *
5 * Copyright (c) 2016-2018, NVIDIA CORPORATION. All rights reserved.
6 *
7 * Author: Mallikarjun Kasoju <mkasoju@nvidia.com>
8 * Laxman Dewangan <ldewangan@nvidia.com>
9 */
10
11#include <linux/init.h>
12#include <linux/mfd/max77620.h>
13#include <linux/module.h>
14#include <linux/of.h>
15#include <linux/platform_device.h>
16#include <linux/regmap.h>
17#include <linux/regulator/driver.h>
18#include <linux/regulator/machine.h>
19#include <linux/regulator/of_regulator.h>
20
21#define max77620_rails(_name) "max77620-"#_name
22
23/* Power Mode */
24#define MAX77620_POWER_MODE_NORMAL 3
25#define MAX77620_POWER_MODE_LPM 2
26#define MAX77620_POWER_MODE_GLPM 1
27#define MAX77620_POWER_MODE_DISABLE 0
28
29/* SD Slew Rate */
30#define MAX77620_SD_SR_13_75 0
31#define MAX77620_SD_SR_27_5 1
32#define MAX77620_SD_SR_55 2
33#define MAX77620_SD_SR_100 3
34
35enum max77620_regulators {
36 MAX77620_REGULATOR_ID_SD0,
37 MAX77620_REGULATOR_ID_SD1,
38 MAX77620_REGULATOR_ID_SD2,
39 MAX77620_REGULATOR_ID_SD3,
40 MAX77620_REGULATOR_ID_SD4,
41 MAX77620_REGULATOR_ID_LDO0,
42 MAX77620_REGULATOR_ID_LDO1,
43 MAX77620_REGULATOR_ID_LDO2,
44 MAX77620_REGULATOR_ID_LDO3,
45 MAX77620_REGULATOR_ID_LDO4,
46 MAX77620_REGULATOR_ID_LDO5,
47 MAX77620_REGULATOR_ID_LDO6,
48 MAX77620_REGULATOR_ID_LDO7,
49 MAX77620_REGULATOR_ID_LDO8,
50 MAX77620_NUM_REGS,
51};
52
53/* Regulator types */
54enum max77620_regulator_type {
55 MAX77620_REGULATOR_TYPE_SD,
56 MAX77620_REGULATOR_TYPE_LDO_N,
57 MAX77620_REGULATOR_TYPE_LDO_P,
58};
59
60struct max77620_regulator_info {
61 u8 type;
62 u8 fps_addr;
63 u8 volt_addr;
64 u8 cfg_addr;
65 u8 power_mode_mask;
66 u8 power_mode_shift;
67 u8 remote_sense_addr;
68 u8 remote_sense_mask;
69 struct regulator_desc desc;
70};
71
72struct max77620_regulator_pdata {
73 int active_fps_src;
74 int active_fps_pd_slot;
75 int active_fps_pu_slot;
76 int suspend_fps_src;
77 int suspend_fps_pd_slot;
78 int suspend_fps_pu_slot;
79 int current_mode;
80 int power_ok;
81 int ramp_rate_setting;
82};
83
84struct max77620_regulator {
85 struct device *dev;
86 struct regmap *rmap;
87 struct max77620_regulator_info *rinfo[MAX77620_NUM_REGS];
88 struct max77620_regulator_pdata reg_pdata[MAX77620_NUM_REGS];
89 int enable_power_mode[MAX77620_NUM_REGS];
90 int current_power_mode[MAX77620_NUM_REGS];
91 int active_fps_src[MAX77620_NUM_REGS];
92};
93
94#define fps_src_name(fps_src) \
95 (fps_src == MAX77620_FPS_SRC_0 ? "FPS_SRC_0" : \
96 fps_src == MAX77620_FPS_SRC_1 ? "FPS_SRC_1" : \
97 fps_src == MAX77620_FPS_SRC_2 ? "FPS_SRC_2" : "FPS_SRC_NONE")
98
99static int max77620_regulator_get_fps_src(struct max77620_regulator *pmic,
100 int id)
101{
102 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
103 unsigned int val;
104 int ret;
105
106 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
107 if (ret < 0) {
108 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
109 rinfo->fps_addr, ret);
110 return ret;
111 }
112
113 return (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
114}
115
116static int max77620_regulator_set_fps_src(struct max77620_regulator *pmic,
117 int fps_src, int id)
118{
119 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
120 unsigned int val;
121 int ret;
122
123 if (!rinfo)
124 return 0;
125
126 switch (fps_src) {
127 case MAX77620_FPS_SRC_0:
128 case MAX77620_FPS_SRC_1:
129 case MAX77620_FPS_SRC_2:
130 case MAX77620_FPS_SRC_NONE:
131 break;
132
133 case MAX77620_FPS_SRC_DEF:
134 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
135 if (ret < 0) {
136 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
137 rinfo->fps_addr, ret);
138 return ret;
139 }
140 ret = (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
141 pmic->active_fps_src[id] = ret;
142 return 0;
143
144 default:
145 dev_err(pmic->dev, "Invalid FPS %d for regulator %d\n",
146 fps_src, id);
147 return -EINVAL;
148 }
149
150 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
151 MAX77620_FPS_SRC_MASK,
152 fps_src << MAX77620_FPS_SRC_SHIFT);
153 if (ret < 0) {
154 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
155 rinfo->fps_addr, ret);
156 return ret;
157 }
158 pmic->active_fps_src[id] = fps_src;
159
160 return 0;
161}
162
163static int max77620_regulator_set_fps_slots(struct max77620_regulator *pmic,
164 int id, bool is_suspend)
165{
166 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
167 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
168 unsigned int val = 0;
169 unsigned int mask = 0;
170 int pu = rpdata->active_fps_pu_slot;
171 int pd = rpdata->active_fps_pd_slot;
172 int ret = 0;
173
174 if (!rinfo)
175 return 0;
176
177 if (is_suspend) {
178 pu = rpdata->suspend_fps_pu_slot;
179 pd = rpdata->suspend_fps_pd_slot;
180 }
181
182 /* FPS power up period setting */
183 if (pu >= 0) {
184 val |= (pu << MAX77620_FPS_PU_PERIOD_SHIFT);
185 mask |= MAX77620_FPS_PU_PERIOD_MASK;
186 }
187
188 /* FPS power down period setting */
189 if (pd >= 0) {
190 val |= (pd << MAX77620_FPS_PD_PERIOD_SHIFT);
191 mask |= MAX77620_FPS_PD_PERIOD_MASK;
192 }
193
194 if (mask) {
195 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
196 mask, val);
197 if (ret < 0) {
198 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
199 rinfo->fps_addr, ret);
200 return ret;
201 }
202 }
203
204 return ret;
205}
206
207static int max77620_regulator_set_power_mode(struct max77620_regulator *pmic,
208 int power_mode, int id)
209{
210 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
211 u8 mask = rinfo->power_mode_mask;
212 u8 shift = rinfo->power_mode_shift;
213 u8 addr;
214 int ret;
215
216 switch (rinfo->type) {
217 case MAX77620_REGULATOR_TYPE_SD:
218 addr = rinfo->cfg_addr;
219 break;
220 default:
221 addr = rinfo->volt_addr;
222 break;
223 }
224
225 ret = regmap_update_bits(pmic->rmap, addr, mask, power_mode << shift);
226 if (ret < 0) {
227 dev_err(pmic->dev, "Regulator %d mode set failed: %d\n",
228 id, ret);
229 return ret;
230 }
231 pmic->current_power_mode[id] = power_mode;
232
233 return ret;
234}
235
236static int max77620_regulator_get_power_mode(struct max77620_regulator *pmic,
237 int id)
238{
239 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
240 unsigned int val, addr;
241 u8 mask = rinfo->power_mode_mask;
242 u8 shift = rinfo->power_mode_shift;
243 int ret;
244
245 switch (rinfo->type) {
246 case MAX77620_REGULATOR_TYPE_SD:
247 addr = rinfo->cfg_addr;
248 break;
249 default:
250 addr = rinfo->volt_addr;
251 break;
252 }
253
254 ret = regmap_read(pmic->rmap, addr, &val);
255 if (ret < 0) {
256 dev_err(pmic->dev, "Regulator %d: Reg 0x%02x read failed: %d\n",
257 id, addr, ret);
258 return ret;
259 }
260
261 return (val & mask) >> shift;
262}
263
264static int max77620_read_slew_rate(struct max77620_regulator *pmic, int id)
265{
266 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
267 unsigned int rval;
268 int slew_rate;
269 int ret;
270
271 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &rval);
272 if (ret < 0) {
273 dev_err(pmic->dev, "Register 0x%02x read failed: %d\n",
274 rinfo->cfg_addr, ret);
275 return ret;
276 }
277
278 switch (rinfo->type) {
279 case MAX77620_REGULATOR_TYPE_SD:
280 slew_rate = (rval >> MAX77620_SD_SR_SHIFT) & 0x3;
281 switch (slew_rate) {
282 case 0:
283 slew_rate = 13750;
284 break;
285 case 1:
286 slew_rate = 27500;
287 break;
288 case 2:
289 slew_rate = 55000;
290 break;
291 case 3:
292 slew_rate = 100000;
293 break;
294 }
295 rinfo->desc.ramp_delay = slew_rate;
296 break;
297 default:
298 slew_rate = rval & 0x1;
299 switch (slew_rate) {
300 case 0:
301 slew_rate = 100000;
302 break;
303 case 1:
304 slew_rate = 5000;
305 break;
306 }
307 rinfo->desc.ramp_delay = slew_rate;
308 break;
309 }
310
311 return 0;
312}
313
314static int max77620_set_slew_rate(struct max77620_regulator *pmic, int id,
315 int slew_rate)
316{
317 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
318 unsigned int val;
319 int ret;
320 u8 mask;
321
322 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
323 if (slew_rate <= 13750)
324 val = 0;
325 else if (slew_rate <= 27500)
326 val = 1;
327 else if (slew_rate <= 55000)
328 val = 2;
329 else
330 val = 3;
331 val <<= MAX77620_SD_SR_SHIFT;
332 mask = MAX77620_SD_SR_MASK;
333 } else {
334 if (slew_rate <= 5000)
335 val = 1;
336 else
337 val = 0;
338 mask = MAX77620_LDO_SLEW_RATE_MASK;
339 }
340
341 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr, mask, val);
342 if (ret < 0) {
343 dev_err(pmic->dev, "Regulator %d slew rate set failed: %d\n",
344 id, ret);
345 return ret;
346 }
347
348 return 0;
349}
350
351static int max77620_config_power_ok(struct max77620_regulator *pmic, int id)
352{
353 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
354 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
355 struct max77620_chip *chip = dev_get_drvdata(pmic->dev->parent);
356 u8 val, mask;
357 int ret;
358
359 switch (chip->chip_id) {
360 case MAX20024:
361 if (rpdata->power_ok >= 0) {
362 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD)
363 mask = MAX20024_SD_CFG1_MPOK_MASK;
364 else
365 mask = MAX20024_LDO_CFG2_MPOK_MASK;
366
367 val = rpdata->power_ok ? mask : 0;
368
369 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
370 mask, val);
371 if (ret < 0) {
372 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
373 rinfo->cfg_addr, ret);
374 return ret;
375 }
376 }
377 break;
378
379 default:
380 break;
381 }
382
383 return 0;
384}
385
386static int max77620_init_pmic(struct max77620_regulator *pmic, int id)
387{
388 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
389 int ret;
390
391 max77620_config_power_ok(pmic, id);
392
393 /* Update power mode */
394 ret = max77620_regulator_get_power_mode(pmic, id);
395 if (ret < 0)
396 return ret;
397
398 pmic->current_power_mode[id] = ret;
399 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
400
401 if (rpdata->active_fps_src == MAX77620_FPS_SRC_DEF) {
402 ret = max77620_regulator_get_fps_src(pmic, id);
403 if (ret < 0)
404 return ret;
405 rpdata->active_fps_src = ret;
406 }
407
408 /* If rails are externally control of FPS then enable it always. */
409 if (rpdata->active_fps_src == MAX77620_FPS_SRC_NONE) {
410 ret = max77620_regulator_set_power_mode(pmic,
411 pmic->enable_power_mode[id], id);
412 if (ret < 0)
413 return ret;
414 } else {
415 if (pmic->current_power_mode[id] !=
416 pmic->enable_power_mode[id]) {
417 ret = max77620_regulator_set_power_mode(pmic,
418 pmic->enable_power_mode[id], id);
419 if (ret < 0)
420 return ret;
421 }
422 }
423
424 ret = max77620_regulator_set_fps_src(pmic, rpdata->active_fps_src, id);
425 if (ret < 0)
426 return ret;
427
428 ret = max77620_regulator_set_fps_slots(pmic, id, false);
429 if (ret < 0)
430 return ret;
431
432 if (rpdata->ramp_rate_setting) {
433 ret = max77620_set_slew_rate(pmic, id,
434 rpdata->ramp_rate_setting);
435 if (ret < 0)
436 return ret;
437 }
438
439 return 0;
440}
441
442static int max77620_regulator_enable(struct regulator_dev *rdev)
443{
444 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
445 int id = rdev_get_id(rdev);
446
447 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
448 return 0;
449
450 return max77620_regulator_set_power_mode(pmic,
451 pmic->enable_power_mode[id], id);
452}
453
454static int max77620_regulator_disable(struct regulator_dev *rdev)
455{
456 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
457 int id = rdev_get_id(rdev);
458
459 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
460 return 0;
461
462 return max77620_regulator_set_power_mode(pmic,
463 MAX77620_POWER_MODE_DISABLE, id);
464}
465
466static int max77620_regulator_is_enabled(struct regulator_dev *rdev)
467{
468 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
469 int id = rdev_get_id(rdev);
470 int ret;
471
472 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
473 return 1;
474
475 ret = max77620_regulator_get_power_mode(pmic, id);
476 if (ret < 0)
477 return ret;
478
479 if (ret != MAX77620_POWER_MODE_DISABLE)
480 return 1;
481
482 return 0;
483}
484
485static int max77620_regulator_set_mode(struct regulator_dev *rdev,
486 unsigned int mode)
487{
488 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
489 int id = rdev_get_id(rdev);
490 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
491 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
492 bool fpwm = false;
493 int power_mode;
494 int ret;
495 u8 val;
496
497 switch (mode) {
498 case REGULATOR_MODE_FAST:
499 fpwm = true;
500 power_mode = MAX77620_POWER_MODE_NORMAL;
501 break;
502
503 case REGULATOR_MODE_NORMAL:
504 power_mode = MAX77620_POWER_MODE_NORMAL;
505 break;
506
507 case REGULATOR_MODE_IDLE:
508 power_mode = MAX77620_POWER_MODE_LPM;
509 break;
510
511 default:
512 dev_err(pmic->dev, "Regulator %d mode %d is invalid\n",
513 id, mode);
514 return -EINVAL;
515 }
516
517 if (rinfo->type != MAX77620_REGULATOR_TYPE_SD)
518 goto skip_fpwm;
519
520 val = (fpwm) ? MAX77620_SD_FPWM_MASK : 0;
521 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
522 MAX77620_SD_FPWM_MASK, val);
523 if (ret < 0) {
524 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
525 rinfo->cfg_addr, ret);
526 return ret;
527 }
528 rpdata->current_mode = mode;
529
530skip_fpwm:
531 ret = max77620_regulator_set_power_mode(pmic, power_mode, id);
532 if (ret < 0)
533 return ret;
534
535 pmic->enable_power_mode[id] = power_mode;
536
537 return 0;
538}
539
540static unsigned int max77620_regulator_get_mode(struct regulator_dev *rdev)
541{
542 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
543 int id = rdev_get_id(rdev);
544 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
545 int fpwm = 0;
546 int ret;
547 int pm_mode, reg_mode;
548 unsigned int val;
549
550 ret = max77620_regulator_get_power_mode(pmic, id);
551 if (ret < 0)
552 return 0;
553
554 pm_mode = ret;
555
556 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
557 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &val);
558 if (ret < 0) {
559 dev_err(pmic->dev, "Reg 0x%02x read failed: %d\n",
560 rinfo->cfg_addr, ret);
561 return ret;
562 }
563 fpwm = !!(val & MAX77620_SD_FPWM_MASK);
564 }
565
566 switch (pm_mode) {
567 case MAX77620_POWER_MODE_NORMAL:
568 case MAX77620_POWER_MODE_DISABLE:
569 if (fpwm)
570 reg_mode = REGULATOR_MODE_FAST;
571 else
572 reg_mode = REGULATOR_MODE_NORMAL;
573 break;
574 case MAX77620_POWER_MODE_LPM:
575 case MAX77620_POWER_MODE_GLPM:
576 reg_mode = REGULATOR_MODE_IDLE;
577 break;
578 default:
579 return 0;
580 }
581
582 return reg_mode;
583}
584
585static int max77620_regulator_set_ramp_delay(struct regulator_dev *rdev,
586 int ramp_delay)
587{
588 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
589 int id = rdev_get_id(rdev);
590 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
591
592 /* Device specific ramp rate setting tells that platform has
593 * different ramp rate from advertised value. In this case,
594 * do not configure anything and just return success.
595 */
596 if (rpdata->ramp_rate_setting)
597 return 0;
598
599 return max77620_set_slew_rate(pmic, id, ramp_delay);
600}
601
602static int max77620_of_parse_cb(struct device_node *np,
603 const struct regulator_desc *desc,
604 struct regulator_config *config)
605{
606 struct max77620_regulator *pmic = config->driver_data;
607 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[desc->id];
608 u32 pval;
609 int ret;
610
611 ret = of_property_read_u32(np, "maxim,active-fps-source", &pval);
612 rpdata->active_fps_src = (!ret) ? pval : MAX77620_FPS_SRC_DEF;
613
614 ret = of_property_read_u32(np, "maxim,active-fps-power-up-slot", &pval);
615 rpdata->active_fps_pu_slot = (!ret) ? pval : -1;
616
617 ret = of_property_read_u32(
618 np, "maxim,active-fps-power-down-slot", &pval);
619 rpdata->active_fps_pd_slot = (!ret) ? pval : -1;
620
621 ret = of_property_read_u32(np, "maxim,suspend-fps-source", &pval);
622 rpdata->suspend_fps_src = (!ret) ? pval : -1;
623
624 ret = of_property_read_u32(
625 np, "maxim,suspend-fps-power-up-slot", &pval);
626 rpdata->suspend_fps_pu_slot = (!ret) ? pval : -1;
627
628 ret = of_property_read_u32(
629 np, "maxim,suspend-fps-power-down-slot", &pval);
630 rpdata->suspend_fps_pd_slot = (!ret) ? pval : -1;
631
632 ret = of_property_read_u32(np, "maxim,power-ok-control", &pval);
633 if (!ret)
634 rpdata->power_ok = pval;
635 else
636 rpdata->power_ok = -1;
637
638 ret = of_property_read_u32(np, "maxim,ramp-rate-setting", &pval);
639 rpdata->ramp_rate_setting = (!ret) ? pval : 0;
640
641 return max77620_init_pmic(pmic, desc->id);
642}
643
644static const struct regulator_ops max77620_regulator_ops = {
645 .is_enabled = max77620_regulator_is_enabled,
646 .enable = max77620_regulator_enable,
647 .disable = max77620_regulator_disable,
648 .list_voltage = regulator_list_voltage_linear,
649 .map_voltage = regulator_map_voltage_linear,
650 .get_voltage_sel = regulator_get_voltage_sel_regmap,
651 .set_voltage_sel = regulator_set_voltage_sel_regmap,
652 .set_mode = max77620_regulator_set_mode,
653 .get_mode = max77620_regulator_get_mode,
654 .set_ramp_delay = max77620_regulator_set_ramp_delay,
655 .set_voltage_time_sel = regulator_set_voltage_time_sel,
656 .set_active_discharge = regulator_set_active_discharge_regmap,
657};
658
659#define MAX77620_SD_CNF2_ROVS_EN_NONE 0
660#define RAIL_SD(_id, _name, _sname, _volt_mask, _min_uV, _max_uV, \
661 _step_uV, _rs_add, _rs_mask) \
662 [MAX77620_REGULATOR_ID_##_id] = { \
663 .type = MAX77620_REGULATOR_TYPE_SD, \
664 .volt_addr = MAX77620_REG_##_id, \
665 .cfg_addr = MAX77620_REG_##_id##_CFG, \
666 .fps_addr = MAX77620_REG_FPS_##_id, \
667 .remote_sense_addr = _rs_add, \
668 .remote_sense_mask = MAX77620_SD_CNF2_ROVS_EN_##_rs_mask, \
669 .power_mode_mask = MAX77620_SD_POWER_MODE_MASK, \
670 .power_mode_shift = MAX77620_SD_POWER_MODE_SHIFT, \
671 .desc = { \
672 .name = max77620_rails(_name), \
673 .of_match = of_match_ptr(#_name), \
674 .regulators_node = of_match_ptr("regulators"), \
675 .of_parse_cb = max77620_of_parse_cb, \
676 .supply_name = _sname, \
677 .id = MAX77620_REGULATOR_ID_##_id, \
678 .ops = &max77620_regulator_ops, \
679 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
680 .min_uV = _min_uV, \
681 .uV_step = _step_uV, \
682 .enable_time = 500, \
683 .vsel_mask = MAX77620_##_volt_mask##_VOLT_MASK, \
684 .vsel_reg = MAX77620_REG_##_id, \
685 .active_discharge_off = 0, \
686 .active_discharge_on = MAX77620_SD_CFG1_ADE_ENABLE, \
687 .active_discharge_mask = MAX77620_SD_CFG1_ADE_MASK, \
688 .active_discharge_reg = MAX77620_REG_##_id##_CFG, \
689 .type = REGULATOR_VOLTAGE, \
690 .owner = THIS_MODULE, \
691 }, \
692 }
693
694#define RAIL_LDO(_id, _name, _sname, _type, _min_uV, _max_uV, _step_uV) \
695 [MAX77620_REGULATOR_ID_##_id] = { \
696 .type = MAX77620_REGULATOR_TYPE_LDO_##_type, \
697 .volt_addr = MAX77620_REG_##_id##_CFG, \
698 .cfg_addr = MAX77620_REG_##_id##_CFG2, \
699 .fps_addr = MAX77620_REG_FPS_##_id, \
700 .remote_sense_addr = 0xFF, \
701 .power_mode_mask = MAX77620_LDO_POWER_MODE_MASK, \
702 .power_mode_shift = MAX77620_LDO_POWER_MODE_SHIFT, \
703 .desc = { \
704 .name = max77620_rails(_name), \
705 .of_match = of_match_ptr(#_name), \
706 .regulators_node = of_match_ptr("regulators"), \
707 .of_parse_cb = max77620_of_parse_cb, \
708 .supply_name = _sname, \
709 .id = MAX77620_REGULATOR_ID_##_id, \
710 .ops = &max77620_regulator_ops, \
711 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
712 .min_uV = _min_uV, \
713 .uV_step = _step_uV, \
714 .enable_time = 500, \
715 .vsel_mask = MAX77620_LDO_VOLT_MASK, \
716 .vsel_reg = MAX77620_REG_##_id##_CFG, \
717 .active_discharge_off = 0, \
718 .active_discharge_on = MAX77620_LDO_CFG2_ADE_ENABLE, \
719 .active_discharge_mask = MAX77620_LDO_CFG2_ADE_MASK, \
720 .active_discharge_reg = MAX77620_REG_##_id##_CFG2, \
721 .type = REGULATOR_VOLTAGE, \
722 .owner = THIS_MODULE, \
723 }, \
724 }
725
726static struct max77620_regulator_info max77620_regs_info[MAX77620_NUM_REGS] = {
727 RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 1400000, 12500, 0x22, SD0),
728 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 1550000, 12500, 0x22, SD1),
729 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
730 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
731
732 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
733 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
734 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
735 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
736 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
737 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
738 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
739 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
740 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
741};
742
743static struct max77620_regulator_info max20024_regs_info[MAX77620_NUM_REGS] = {
744 RAIL_SD(SD0, sd0, "in-sd0", SD0, 800000, 1587500, 12500, 0x22, SD0),
745 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 3387500, 12500, 0x22, SD1),
746 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
747 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
748 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
749
750 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
751 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
752 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
753 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
754 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
755 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
756 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
757 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
758 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
759};
760
761static struct max77620_regulator_info max77663_regs_info[MAX77620_NUM_REGS] = {
762 RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 3387500, 12500, 0xFF, NONE),
763 RAIL_SD(SD1, sd1, "in-sd1", SD1, 800000, 1587500, 12500, 0xFF, NONE),
764 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
765 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
766 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
767
768 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
769 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
770 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
771 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
772 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
773 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
774 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
775 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
776 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
777};
778
779static int max77620_regulator_probe(struct platform_device *pdev)
780{
781 struct max77620_chip *max77620_chip = dev_get_drvdata(pdev->dev.parent);
782 struct max77620_regulator_info *rinfo;
783 struct device *dev = &pdev->dev;
784 struct regulator_config config = { };
785 struct max77620_regulator *pmic;
786 int ret = 0;
787 int id;
788
789 pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL);
790 if (!pmic)
791 return -ENOMEM;
792
793 platform_set_drvdata(pdev, pmic);
794 pmic->dev = dev;
795 pmic->rmap = max77620_chip->rmap;
796 if (!dev->of_node)
797 dev->of_node = pdev->dev.parent->of_node;
798
799 switch (max77620_chip->chip_id) {
800 case MAX77620:
801 rinfo = max77620_regs_info;
802 break;
803 case MAX20024:
804 rinfo = max20024_regs_info;
805 break;
806 case MAX77663:
807 rinfo = max77663_regs_info;
808 break;
809 default:
810 return -EINVAL;
811 }
812
813 config.regmap = pmic->rmap;
814 config.dev = dev;
815 config.driver_data = pmic;
816
817 /*
818 * Set of_node_reuse flag to prevent driver core from attempting to
819 * claim any pinmux resources already claimed by the parent device.
820 * Otherwise PMIC driver will fail to re-probe.
821 */
822 device_set_of_node_from_dev(&pdev->dev, pdev->dev.parent);
823
824 for (id = 0; id < MAX77620_NUM_REGS; id++) {
825 struct regulator_dev *rdev;
826 struct regulator_desc *rdesc;
827
828 if ((max77620_chip->chip_id == MAX77620) &&
829 (id == MAX77620_REGULATOR_ID_SD4))
830 continue;
831
832 rdesc = &rinfo[id].desc;
833 pmic->rinfo[id] = &rinfo[id];
834 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
835 pmic->reg_pdata[id].active_fps_src = -1;
836 pmic->reg_pdata[id].active_fps_pd_slot = -1;
837 pmic->reg_pdata[id].active_fps_pu_slot = -1;
838 pmic->reg_pdata[id].suspend_fps_src = -1;
839 pmic->reg_pdata[id].suspend_fps_pd_slot = -1;
840 pmic->reg_pdata[id].suspend_fps_pu_slot = -1;
841 pmic->reg_pdata[id].power_ok = -1;
842 pmic->reg_pdata[id].ramp_rate_setting = -1;
843
844 ret = max77620_read_slew_rate(pmic, id);
845 if (ret < 0)
846 return ret;
847
848 rdev = devm_regulator_register(dev, rdesc, &config);
849 if (IS_ERR(rdev))
850 return dev_err_probe(dev, PTR_ERR(rdev),
851 "Regulator registration %s failed\n",
852 rdesc->name);
853 }
854
855 return 0;
856}
857
858#ifdef CONFIG_PM_SLEEP
859static int max77620_regulator_suspend(struct device *dev)
860{
861 struct max77620_regulator *pmic = dev_get_drvdata(dev);
862 struct max77620_regulator_pdata *reg_pdata;
863 int id;
864
865 for (id = 0; id < MAX77620_NUM_REGS; id++) {
866 reg_pdata = &pmic->reg_pdata[id];
867
868 max77620_regulator_set_fps_slots(pmic, id, true);
869 if (reg_pdata->suspend_fps_src < 0)
870 continue;
871
872 max77620_regulator_set_fps_src(pmic, reg_pdata->suspend_fps_src,
873 id);
874 }
875
876 return 0;
877}
878
879static int max77620_regulator_resume(struct device *dev)
880{
881 struct max77620_regulator *pmic = dev_get_drvdata(dev);
882 struct max77620_regulator_pdata *reg_pdata;
883 int id;
884
885 for (id = 0; id < MAX77620_NUM_REGS; id++) {
886 reg_pdata = &pmic->reg_pdata[id];
887
888 max77620_config_power_ok(pmic, id);
889
890 max77620_regulator_set_fps_slots(pmic, id, false);
891 if (reg_pdata->active_fps_src < 0)
892 continue;
893 max77620_regulator_set_fps_src(pmic, reg_pdata->active_fps_src,
894 id);
895 }
896
897 return 0;
898}
899#endif
900
901static const struct dev_pm_ops max77620_regulator_pm_ops = {
902 SET_SYSTEM_SLEEP_PM_OPS(max77620_regulator_suspend,
903 max77620_regulator_resume)
904};
905
906static const struct platform_device_id max77620_regulator_devtype[] = {
907 { .name = "max77620-pmic", },
908 { .name = "max20024-pmic", },
909 { .name = "max77663-pmic", },
910 {},
911};
912MODULE_DEVICE_TABLE(platform, max77620_regulator_devtype);
913
914static struct platform_driver max77620_regulator_driver = {
915 .probe = max77620_regulator_probe,
916 .id_table = max77620_regulator_devtype,
917 .driver = {
918 .name = "max77620-pmic",
919 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
920 .pm = &max77620_regulator_pm_ops,
921 },
922};
923
924module_platform_driver(max77620_regulator_driver);
925
926MODULE_DESCRIPTION("MAX77620/MAX20024 regulator driver");
927MODULE_AUTHOR("Mallikarjun Kasoju <mkasoju@nvidia.com>");
928MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
929MODULE_LICENSE("GPL v2");
1/*
2 * Maxim MAX77620 Regulator driver
3 *
4 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
5 *
6 * Author: Mallikarjun Kasoju <mkasoju@nvidia.com>
7 * Laxman Dewangan <ldewangan@nvidia.com>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms and conditions of the GNU General Public License,
11 * version 2, as published by the Free Software Foundation.
12 */
13
14#include <linux/init.h>
15#include <linux/mfd/max77620.h>
16#include <linux/module.h>
17#include <linux/of.h>
18#include <linux/platform_device.h>
19#include <linux/regmap.h>
20#include <linux/regulator/driver.h>
21#include <linux/regulator/machine.h>
22#include <linux/regulator/of_regulator.h>
23
24#define max77620_rails(_name) "max77620-"#_name
25
26/* Power Mode */
27#define MAX77620_POWER_MODE_NORMAL 3
28#define MAX77620_POWER_MODE_LPM 2
29#define MAX77620_POWER_MODE_GLPM 1
30#define MAX77620_POWER_MODE_DISABLE 0
31
32/* SD Slew Rate */
33#define MAX77620_SD_SR_13_75 0
34#define MAX77620_SD_SR_27_5 1
35#define MAX77620_SD_SR_55 2
36#define MAX77620_SD_SR_100 3
37
38enum max77620_regulators {
39 MAX77620_REGULATOR_ID_SD0,
40 MAX77620_REGULATOR_ID_SD1,
41 MAX77620_REGULATOR_ID_SD2,
42 MAX77620_REGULATOR_ID_SD3,
43 MAX77620_REGULATOR_ID_SD4,
44 MAX77620_REGULATOR_ID_LDO0,
45 MAX77620_REGULATOR_ID_LDO1,
46 MAX77620_REGULATOR_ID_LDO2,
47 MAX77620_REGULATOR_ID_LDO3,
48 MAX77620_REGULATOR_ID_LDO4,
49 MAX77620_REGULATOR_ID_LDO5,
50 MAX77620_REGULATOR_ID_LDO6,
51 MAX77620_REGULATOR_ID_LDO7,
52 MAX77620_REGULATOR_ID_LDO8,
53 MAX77620_NUM_REGS,
54};
55
56/* Regulator types */
57enum max77620_regulator_type {
58 MAX77620_REGULATOR_TYPE_SD,
59 MAX77620_REGULATOR_TYPE_LDO_N,
60 MAX77620_REGULATOR_TYPE_LDO_P,
61};
62
63struct max77620_regulator_info {
64 u8 type;
65 u8 fps_addr;
66 u8 volt_addr;
67 u8 cfg_addr;
68 u8 power_mode_mask;
69 u8 power_mode_shift;
70 u8 remote_sense_addr;
71 u8 remote_sense_mask;
72 struct regulator_desc desc;
73};
74
75struct max77620_regulator_pdata {
76 struct regulator_init_data *reg_idata;
77 int active_fps_src;
78 int active_fps_pd_slot;
79 int active_fps_pu_slot;
80 int suspend_fps_src;
81 int suspend_fps_pd_slot;
82 int suspend_fps_pu_slot;
83 int current_mode;
84};
85
86struct max77620_regulator {
87 struct device *dev;
88 struct regmap *rmap;
89 struct max77620_regulator_info *rinfo[MAX77620_NUM_REGS];
90 struct max77620_regulator_pdata reg_pdata[MAX77620_NUM_REGS];
91 int enable_power_mode[MAX77620_NUM_REGS];
92 int current_power_mode[MAX77620_NUM_REGS];
93 int active_fps_src[MAX77620_NUM_REGS];
94};
95
96#define fps_src_name(fps_src) \
97 (fps_src == MAX77620_FPS_SRC_0 ? "FPS_SRC_0" : \
98 fps_src == MAX77620_FPS_SRC_1 ? "FPS_SRC_1" : \
99 fps_src == MAX77620_FPS_SRC_2 ? "FPS_SRC_2" : "FPS_SRC_NONE")
100
101static int max77620_regulator_get_fps_src(struct max77620_regulator *pmic,
102 int id)
103{
104 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
105 unsigned int val;
106 int ret;
107
108 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
109 if (ret < 0) {
110 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
111 rinfo->fps_addr, ret);
112 return ret;
113 }
114
115 return (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
116}
117
118static int max77620_regulator_set_fps_src(struct max77620_regulator *pmic,
119 int fps_src, int id)
120{
121 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
122 unsigned int val;
123 int ret;
124
125 switch (fps_src) {
126 case MAX77620_FPS_SRC_0:
127 case MAX77620_FPS_SRC_1:
128 case MAX77620_FPS_SRC_2:
129 case MAX77620_FPS_SRC_NONE:
130 break;
131
132 case MAX77620_FPS_SRC_DEF:
133 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
134 if (ret < 0) {
135 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
136 rinfo->fps_addr, ret);
137 return ret;
138 }
139 ret = (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
140 pmic->active_fps_src[id] = ret;
141 return 0;
142
143 default:
144 dev_err(pmic->dev, "Invalid FPS %d for regulator %d\n",
145 fps_src, id);
146 return -EINVAL;
147 }
148
149 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
150 MAX77620_FPS_SRC_MASK,
151 fps_src << MAX77620_FPS_SRC_SHIFT);
152 if (ret < 0) {
153 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
154 rinfo->fps_addr, ret);
155 return ret;
156 }
157 pmic->active_fps_src[id] = fps_src;
158
159 return 0;
160}
161
162static int max77620_regulator_set_fps_slots(struct max77620_regulator *pmic,
163 int id, bool is_suspend)
164{
165 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
166 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
167 unsigned int val = 0;
168 unsigned int mask = 0;
169 int pu = rpdata->active_fps_pu_slot;
170 int pd = rpdata->active_fps_pd_slot;
171 int ret = 0;
172
173 if (is_suspend) {
174 pu = rpdata->suspend_fps_pu_slot;
175 pd = rpdata->suspend_fps_pd_slot;
176 }
177
178 /* FPS power up period setting */
179 if (pu >= 0) {
180 val |= (pu << MAX77620_FPS_PU_PERIOD_SHIFT);
181 mask |= MAX77620_FPS_PU_PERIOD_MASK;
182 }
183
184 /* FPS power down period setting */
185 if (pd >= 0) {
186 val |= (pd << MAX77620_FPS_PD_PERIOD_SHIFT);
187 mask |= MAX77620_FPS_PD_PERIOD_MASK;
188 }
189
190 if (mask) {
191 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
192 mask, val);
193 if (ret < 0) {
194 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
195 rinfo->fps_addr, ret);
196 return ret;
197 }
198 }
199
200 return ret;
201}
202
203static int max77620_regulator_set_power_mode(struct max77620_regulator *pmic,
204 int power_mode, int id)
205{
206 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
207 u8 mask = rinfo->power_mode_mask;
208 u8 shift = rinfo->power_mode_shift;
209 u8 addr;
210 int ret;
211
212 switch (rinfo->type) {
213 case MAX77620_REGULATOR_TYPE_SD:
214 addr = rinfo->cfg_addr;
215 break;
216 default:
217 addr = rinfo->volt_addr;
218 break;
219 }
220
221 ret = regmap_update_bits(pmic->rmap, addr, mask, power_mode << shift);
222 if (ret < 0) {
223 dev_err(pmic->dev, "Regulator %d mode set failed: %d\n",
224 id, ret);
225 return ret;
226 }
227 pmic->current_power_mode[id] = power_mode;
228
229 return ret;
230}
231
232static int max77620_regulator_get_power_mode(struct max77620_regulator *pmic,
233 int id)
234{
235 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
236 unsigned int val, addr;
237 u8 mask = rinfo->power_mode_mask;
238 u8 shift = rinfo->power_mode_shift;
239 int ret;
240
241 switch (rinfo->type) {
242 case MAX77620_REGULATOR_TYPE_SD:
243 addr = rinfo->cfg_addr;
244 break;
245 default:
246 addr = rinfo->volt_addr;
247 break;
248 }
249
250 ret = regmap_read(pmic->rmap, addr, &val);
251 if (ret < 0) {
252 dev_err(pmic->dev, "Regulator %d: Reg 0x%02x read failed: %d\n",
253 id, addr, ret);
254 return ret;
255 }
256
257 return (val & mask) >> shift;
258}
259
260static int max77620_read_slew_rate(struct max77620_regulator *pmic, int id)
261{
262 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
263 unsigned int rval;
264 int slew_rate;
265 int ret;
266
267 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &rval);
268 if (ret < 0) {
269 dev_err(pmic->dev, "Register 0x%02x read failed: %d\n",
270 rinfo->cfg_addr, ret);
271 return ret;
272 }
273
274 switch (rinfo->type) {
275 case MAX77620_REGULATOR_TYPE_SD:
276 slew_rate = (rval >> MAX77620_SD_SR_SHIFT) & 0x3;
277 switch (slew_rate) {
278 case 0:
279 slew_rate = 13750;
280 break;
281 case 1:
282 slew_rate = 27500;
283 break;
284 case 2:
285 slew_rate = 55000;
286 break;
287 case 3:
288 slew_rate = 100000;
289 break;
290 }
291 rinfo->desc.ramp_delay = slew_rate;
292 break;
293 default:
294 slew_rate = rval & 0x1;
295 switch (slew_rate) {
296 case 0:
297 slew_rate = 100000;
298 break;
299 case 1:
300 slew_rate = 5000;
301 break;
302 }
303 rinfo->desc.ramp_delay = slew_rate;
304 break;
305 }
306
307 return 0;
308}
309
310static int max77620_init_pmic(struct max77620_regulator *pmic, int id)
311{
312 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
313 int ret;
314
315 /* Update power mode */
316 ret = max77620_regulator_get_power_mode(pmic, id);
317 if (ret < 0)
318 return ret;
319
320 pmic->current_power_mode[id] = ret;
321 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
322
323 if (rpdata->active_fps_src == MAX77620_FPS_SRC_DEF) {
324 ret = max77620_regulator_get_fps_src(pmic, id);
325 if (ret < 0)
326 return ret;
327 rpdata->active_fps_src = ret;
328 }
329
330 /* If rails are externally control of FPS then enable it always. */
331 if (rpdata->active_fps_src == MAX77620_FPS_SRC_NONE) {
332 ret = max77620_regulator_set_power_mode(pmic,
333 pmic->enable_power_mode[id], id);
334 if (ret < 0)
335 return ret;
336 } else {
337 if (pmic->current_power_mode[id] !=
338 pmic->enable_power_mode[id]) {
339 ret = max77620_regulator_set_power_mode(pmic,
340 pmic->enable_power_mode[id], id);
341 if (ret < 0)
342 return ret;
343 }
344 }
345
346 ret = max77620_regulator_set_fps_src(pmic, rpdata->active_fps_src, id);
347 if (ret < 0)
348 return ret;
349
350 ret = max77620_regulator_set_fps_slots(pmic, id, false);
351 if (ret < 0)
352 return ret;
353
354 return 0;
355}
356
357static int max77620_regulator_enable(struct regulator_dev *rdev)
358{
359 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
360 int id = rdev_get_id(rdev);
361
362 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
363 return 0;
364
365 return max77620_regulator_set_power_mode(pmic,
366 pmic->enable_power_mode[id], id);
367}
368
369static int max77620_regulator_disable(struct regulator_dev *rdev)
370{
371 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
372 int id = rdev_get_id(rdev);
373
374 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
375 return 0;
376
377 return max77620_regulator_set_power_mode(pmic,
378 MAX77620_POWER_MODE_DISABLE, id);
379}
380
381static int max77620_regulator_is_enabled(struct regulator_dev *rdev)
382{
383 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
384 int id = rdev_get_id(rdev);
385 int ret = 1;
386
387 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
388 return 1;
389
390 ret = max77620_regulator_get_power_mode(pmic, id);
391 if (ret < 0)
392 return ret;
393
394 if (ret != MAX77620_POWER_MODE_DISABLE)
395 return 1;
396
397 return 0;
398}
399
400static int max77620_regulator_set_mode(struct regulator_dev *rdev,
401 unsigned int mode)
402{
403 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
404 int id = rdev_get_id(rdev);
405 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
406 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
407 bool fpwm = false;
408 int power_mode;
409 int ret;
410 u8 val;
411
412 switch (mode) {
413 case REGULATOR_MODE_FAST:
414 fpwm = true;
415 power_mode = MAX77620_POWER_MODE_NORMAL;
416 break;
417
418 case REGULATOR_MODE_NORMAL:
419 power_mode = MAX77620_POWER_MODE_NORMAL;
420 break;
421
422 case REGULATOR_MODE_IDLE:
423 power_mode = MAX77620_POWER_MODE_LPM;
424 break;
425
426 default:
427 dev_err(pmic->dev, "Regulator %d mode %d is invalid\n",
428 id, mode);
429 return -EINVAL;
430 }
431
432 if (rinfo->type != MAX77620_REGULATOR_TYPE_SD)
433 goto skip_fpwm;
434
435 val = (fpwm) ? MAX77620_SD_FPWM_MASK : 0;
436 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
437 MAX77620_SD_FPWM_MASK, val);
438 if (ret < 0) {
439 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
440 rinfo->cfg_addr, ret);
441 return ret;
442 }
443 rpdata->current_mode = mode;
444
445skip_fpwm:
446 ret = max77620_regulator_set_power_mode(pmic, power_mode, id);
447 if (ret < 0)
448 return ret;
449
450 pmic->enable_power_mode[id] = power_mode;
451
452 return 0;
453}
454
455static unsigned int max77620_regulator_get_mode(struct regulator_dev *rdev)
456{
457 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
458 int id = rdev_get_id(rdev);
459 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
460 int fpwm = 0;
461 int ret;
462 int pm_mode, reg_mode;
463 unsigned int val;
464
465 ret = max77620_regulator_get_power_mode(pmic, id);
466 if (ret < 0)
467 return 0;
468
469 pm_mode = ret;
470
471 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
472 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &val);
473 if (ret < 0) {
474 dev_err(pmic->dev, "Reg 0x%02x read failed: %d\n",
475 rinfo->cfg_addr, ret);
476 return ret;
477 }
478 fpwm = !!(val & MAX77620_SD_FPWM_MASK);
479 }
480
481 switch (pm_mode) {
482 case MAX77620_POWER_MODE_NORMAL:
483 case MAX77620_POWER_MODE_DISABLE:
484 if (fpwm)
485 reg_mode = REGULATOR_MODE_FAST;
486 else
487 reg_mode = REGULATOR_MODE_NORMAL;
488 break;
489 case MAX77620_POWER_MODE_LPM:
490 case MAX77620_POWER_MODE_GLPM:
491 reg_mode = REGULATOR_MODE_IDLE;
492 break;
493 default:
494 return 0;
495 }
496
497 return reg_mode;
498}
499
500static int max77620_regulator_set_ramp_delay(struct regulator_dev *rdev,
501 int ramp_delay)
502{
503 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
504 int id = rdev_get_id(rdev);
505 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
506 int ret, val;
507 u8 mask;
508
509 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
510 if (ramp_delay <= 13750)
511 val = 0;
512 else if (ramp_delay <= 27500)
513 val = 1;
514 else if (ramp_delay <= 55000)
515 val = 2;
516 else
517 val = 3;
518 val <<= MAX77620_SD_SR_SHIFT;
519 mask = MAX77620_SD_SR_MASK;
520 } else {
521 if (ramp_delay <= 5000)
522 val = 1;
523 else
524 val = 0;
525 mask = MAX77620_LDO_SLEW_RATE_MASK;
526 }
527
528 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr, mask, val);
529 if (ret < 0)
530 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
531 rinfo->cfg_addr, ret);
532
533 return ret;
534}
535
536static int max77620_of_parse_cb(struct device_node *np,
537 const struct regulator_desc *desc,
538 struct regulator_config *config)
539{
540 struct max77620_regulator *pmic = config->driver_data;
541 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[desc->id];
542 u32 pval;
543 int ret;
544
545 ret = of_property_read_u32(np, "maxim,active-fps-source", &pval);
546 rpdata->active_fps_src = (!ret) ? pval : MAX77620_FPS_SRC_DEF;
547
548 ret = of_property_read_u32(np, "maxim,active-fps-power-up-slot", &pval);
549 rpdata->active_fps_pu_slot = (!ret) ? pval : -1;
550
551 ret = of_property_read_u32(
552 np, "maxim,active-fps-power-down-slot", &pval);
553 rpdata->active_fps_pd_slot = (!ret) ? pval : -1;
554
555 ret = of_property_read_u32(np, "maxim,suspend-fps-source", &pval);
556 rpdata->suspend_fps_src = (!ret) ? pval : -1;
557
558 ret = of_property_read_u32(
559 np, "maxim,suspend-fps-power-up-slot", &pval);
560 rpdata->suspend_fps_pu_slot = (!ret) ? pval : -1;
561
562 ret = of_property_read_u32(
563 np, "maxim,suspend-fps-power-down-slot", &pval);
564 rpdata->suspend_fps_pd_slot = (!ret) ? pval : -1;
565
566 return max77620_init_pmic(pmic, desc->id);
567}
568
569static struct regulator_ops max77620_regulator_ops = {
570 .is_enabled = max77620_regulator_is_enabled,
571 .enable = max77620_regulator_enable,
572 .disable = max77620_regulator_disable,
573 .list_voltage = regulator_list_voltage_linear,
574 .map_voltage = regulator_map_voltage_linear,
575 .get_voltage_sel = regulator_get_voltage_sel_regmap,
576 .set_voltage_sel = regulator_set_voltage_sel_regmap,
577 .set_mode = max77620_regulator_set_mode,
578 .get_mode = max77620_regulator_get_mode,
579 .set_ramp_delay = max77620_regulator_set_ramp_delay,
580 .set_voltage_time_sel = regulator_set_voltage_time_sel,
581 .set_active_discharge = regulator_set_active_discharge_regmap,
582};
583
584#define MAX77620_SD_CNF2_ROVS_EN_NONE 0
585#define RAIL_SD(_id, _name, _sname, _volt_mask, _min_uV, _max_uV, \
586 _step_uV, _rs_add, _rs_mask) \
587 [MAX77620_REGULATOR_ID_##_id] = { \
588 .type = MAX77620_REGULATOR_TYPE_SD, \
589 .volt_addr = MAX77620_REG_##_id, \
590 .cfg_addr = MAX77620_REG_##_id##_CFG, \
591 .fps_addr = MAX77620_REG_FPS_##_id, \
592 .remote_sense_addr = _rs_add, \
593 .remote_sense_mask = MAX77620_SD_CNF2_ROVS_EN_##_rs_mask, \
594 .power_mode_mask = MAX77620_SD_POWER_MODE_MASK, \
595 .power_mode_shift = MAX77620_SD_POWER_MODE_SHIFT, \
596 .desc = { \
597 .name = max77620_rails(_name), \
598 .of_match = of_match_ptr(#_name), \
599 .regulators_node = of_match_ptr("regulators"), \
600 .of_parse_cb = max77620_of_parse_cb, \
601 .supply_name = _sname, \
602 .id = MAX77620_REGULATOR_ID_##_id, \
603 .ops = &max77620_regulator_ops, \
604 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
605 .min_uV = _min_uV, \
606 .uV_step = _step_uV, \
607 .enable_time = 500, \
608 .vsel_mask = MAX77620_##_volt_mask##_VOLT_MASK, \
609 .vsel_reg = MAX77620_REG_##_id, \
610 .active_discharge_off = 0, \
611 .active_discharge_on = MAX77620_SD_CFG1_ADE_ENABLE, \
612 .active_discharge_mask = MAX77620_SD_CFG1_ADE_MASK, \
613 .active_discharge_reg = MAX77620_REG_##_id##_CFG, \
614 .type = REGULATOR_VOLTAGE, \
615 }, \
616 }
617
618#define RAIL_LDO(_id, _name, _sname, _type, _min_uV, _max_uV, _step_uV) \
619 [MAX77620_REGULATOR_ID_##_id] = { \
620 .type = MAX77620_REGULATOR_TYPE_LDO_##_type, \
621 .volt_addr = MAX77620_REG_##_id##_CFG, \
622 .cfg_addr = MAX77620_REG_##_id##_CFG2, \
623 .fps_addr = MAX77620_REG_FPS_##_id, \
624 .remote_sense_addr = 0xFF, \
625 .power_mode_mask = MAX77620_LDO_POWER_MODE_MASK, \
626 .power_mode_shift = MAX77620_LDO_POWER_MODE_SHIFT, \
627 .desc = { \
628 .name = max77620_rails(_name), \
629 .of_match = of_match_ptr(#_name), \
630 .regulators_node = of_match_ptr("regulators"), \
631 .of_parse_cb = max77620_of_parse_cb, \
632 .supply_name = _sname, \
633 .id = MAX77620_REGULATOR_ID_##_id, \
634 .ops = &max77620_regulator_ops, \
635 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
636 .min_uV = _min_uV, \
637 .uV_step = _step_uV, \
638 .enable_time = 500, \
639 .vsel_mask = MAX77620_LDO_VOLT_MASK, \
640 .vsel_reg = MAX77620_REG_##_id##_CFG, \
641 .active_discharge_off = 0, \
642 .active_discharge_on = MAX77620_LDO_CFG2_ADE_ENABLE, \
643 .active_discharge_mask = MAX77620_LDO_CFG2_ADE_MASK, \
644 .active_discharge_reg = MAX77620_REG_##_id##_CFG2, \
645 .type = REGULATOR_VOLTAGE, \
646 }, \
647 }
648
649static struct max77620_regulator_info max77620_regs_info[MAX77620_NUM_REGS] = {
650 RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 1400000, 12500, 0x22, SD0),
651 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 1550000, 12500, 0x22, SD1),
652 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
653 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
654 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
655
656 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
657 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
658 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
659 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
660 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
661 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
662 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
663 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
664 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
665};
666
667static struct max77620_regulator_info max20024_regs_info[MAX77620_NUM_REGS] = {
668 RAIL_SD(SD0, sd0, "in-sd0", SD0, 800000, 1587500, 12500, 0x22, SD0),
669 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 3387500, 12500, 0x22, SD1),
670 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
671 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
672 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
673
674 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
675 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
676 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
677 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
678 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
679 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
680 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
681 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
682 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
683};
684
685static int max77620_regulator_probe(struct platform_device *pdev)
686{
687 struct max77620_chip *max77620_chip = dev_get_drvdata(pdev->dev.parent);
688 struct max77620_regulator_info *rinfo;
689 struct device *dev = &pdev->dev;
690 struct regulator_config config = { };
691 struct max77620_regulator *pmic;
692 int ret = 0;
693 int id;
694
695 pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL);
696 if (!pmic)
697 return -ENOMEM;
698
699 platform_set_drvdata(pdev, pmic);
700 pmic->dev = dev;
701 pmic->rmap = max77620_chip->rmap;
702 if (!dev->of_node)
703 dev->of_node = pdev->dev.parent->of_node;
704
705 switch (max77620_chip->chip_id) {
706 case MAX77620:
707 rinfo = max77620_regs_info;
708 break;
709 default:
710 rinfo = max20024_regs_info;
711 break;
712 }
713
714 config.regmap = pmic->rmap;
715 config.dev = dev;
716 config.driver_data = pmic;
717
718 for (id = 0; id < MAX77620_NUM_REGS; id++) {
719 struct regulator_dev *rdev;
720 struct regulator_desc *rdesc;
721
722 if ((max77620_chip->chip_id == MAX77620) &&
723 (id == MAX77620_REGULATOR_ID_SD4))
724 continue;
725
726 rdesc = &rinfo[id].desc;
727 pmic->rinfo[id] = &max77620_regs_info[id];
728 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
729
730 ret = max77620_read_slew_rate(pmic, id);
731 if (ret < 0)
732 return ret;
733
734 rdev = devm_regulator_register(dev, rdesc, &config);
735 if (IS_ERR(rdev)) {
736 ret = PTR_ERR(rdev);
737 dev_err(dev, "Regulator registration %s failed: %d\n",
738 rdesc->name, ret);
739 return ret;
740 }
741 }
742
743 return 0;
744}
745
746#ifdef CONFIG_PM_SLEEP
747static int max77620_regulator_suspend(struct device *dev)
748{
749 struct max77620_regulator *pmic = dev_get_drvdata(dev);
750 struct max77620_regulator_pdata *reg_pdata;
751 int id;
752
753 for (id = 0; id < MAX77620_NUM_REGS; id++) {
754 reg_pdata = &pmic->reg_pdata[id];
755
756 max77620_regulator_set_fps_slots(pmic, id, true);
757 if (reg_pdata->suspend_fps_src < 0)
758 continue;
759
760 max77620_regulator_set_fps_src(pmic, reg_pdata->suspend_fps_src,
761 id);
762 }
763
764 return 0;
765}
766
767static int max77620_regulator_resume(struct device *dev)
768{
769 struct max77620_regulator *pmic = dev_get_drvdata(dev);
770 struct max77620_regulator_pdata *reg_pdata;
771 int id;
772
773 for (id = 0; id < MAX77620_NUM_REGS; id++) {
774 reg_pdata = &pmic->reg_pdata[id];
775
776 max77620_regulator_set_fps_slots(pmic, id, false);
777 if (reg_pdata->active_fps_src < 0)
778 continue;
779 max77620_regulator_set_fps_src(pmic, reg_pdata->active_fps_src,
780 id);
781 }
782
783 return 0;
784}
785#endif
786
787static const struct dev_pm_ops max77620_regulator_pm_ops = {
788 SET_SYSTEM_SLEEP_PM_OPS(max77620_regulator_suspend,
789 max77620_regulator_resume)
790};
791
792static const struct platform_device_id max77620_regulator_devtype[] = {
793 { .name = "max77620-pmic", },
794 { .name = "max20024-pmic", },
795 {},
796};
797MODULE_DEVICE_TABLE(platform, max77620_regulator_devtype);
798
799static struct platform_driver max77620_regulator_driver = {
800 .probe = max77620_regulator_probe,
801 .id_table = max77620_regulator_devtype,
802 .driver = {
803 .name = "max77620-pmic",
804 .pm = &max77620_regulator_pm_ops,
805 },
806};
807
808module_platform_driver(max77620_regulator_driver);
809
810MODULE_DESCRIPTION("MAX77620/MAX20024 regulator driver");
811MODULE_AUTHOR("Mallikarjun Kasoju <mkasoju@nvidia.com>");
812MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
813MODULE_LICENSE("GPL v2");