aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLaxman Dewangan <ldewangan@nvidia.com>2016-02-11 06:56:34 -0500
committerMark Brown <broonie@kernel.org>2016-02-19 11:01:17 -0500
commit5b1c20286fc962d8c19601b7378a4fc32be8fd9e (patch)
treef02c68ce8f792684cc22f4b242179e71a714f752
parent004dd4e4c44e55bd41f20aff457c61b5a791818c (diff)
regulator: max77620: add regulator driver for max77620/max20024
MAXIM Semiconductor's PMIC, MAX77620 and MAX20024 have the multiple DCDC and LDOs. This supplies the power to different components of the system. Also these rails has configuration for ramp time, flexible power sequence, slew rate etc. Add regulator driver to access these rails via regulator APIs. Signed-off-by: Laxman Dewangan <ldewangan@nvidia.com> Signed-off-by: Mallikarjun Kasoju <mkasoju@nvidia.com> Reviewed-by: Krzysztof Kozlowski <k.kozlowski@samsung.com> Signed-off-by: Mark Brown <broonie@kernel.org>
Diffstat
-rw-r--r--drivers/regulator/Kconfig9
-rw-r--r--drivers/regulator/Makefile1
-rw-r--r--drivers/regulator/max77620-regulator.c825
3 files changed, 835 insertions, 0 deletions
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 8155e80dd3f8..b92214bb8dfb 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -343,6 +343,15 @@ config REGULATOR_MAX1586
343 regulator via I2C bus. The provided regulator is suitable 343 regulator via I2C bus. The provided regulator is suitable
344 for PXA27x chips to control VCC_CORE and VCC_USIM voltages. 344 for PXA27x chips to control VCC_CORE and VCC_USIM voltages.
345 345
346config REGULATOR_MAX77620
347 tristate "Maxim 77620/MAX20024 voltage regulator"
348 depends on MFD_MAX77620
349 help
350 This driver controls Maxim MAX77620 voltage output regulator
351 via I2C bus. The provided regulator is suitable for Tegra
352 chip to control Step-Down DC-DC and LDOs. Say Y here to
353 enable the regulator driver.
354
346config REGULATOR_MAX8649 355config REGULATOR_MAX8649
347 tristate "Maxim 8649 voltage regulator" 356 tristate "Maxim 8649 voltage regulator"
348 depends on I2C 357 depends on I2C
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 980b1943fa81..2564c0020b4c 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_REGULATOR_LP8755) += lp8755.o
46obj-$(CONFIG_REGULATOR_LTC3589) += ltc3589.o 46obj-$(CONFIG_REGULATOR_LTC3589) += ltc3589.o
47obj-$(CONFIG_REGULATOR_MAX14577) += max14577.o 47obj-$(CONFIG_REGULATOR_MAX14577) += max14577.o
48obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o 48obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
49obj-$(CONFIG_REGULATOR_MAX77620) += max77620-regulator.o
49obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o 50obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o
50obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o 51obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o
51obj-$(CONFIG_REGULATOR_MAX8907) += max8907-regulator.o 52obj-$(CONFIG_REGULATOR_MAX8907) += max8907-regulator.o
diff --git a/drivers/regulator/max77620-regulator.c b/drivers/regulator/max77620-regulator.c
new file mode 100644
index 000000000000..fee8ad972852
--- /dev/null
+++ b/drivers/regulator/max77620-regulator.c
@@ -0,0 +1,825 @@
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 u32 min_uV;
66 u32 max_uV;
67 u32 step_uV;
68 u8 fps_addr;
69 u8 volt_addr;
70 u8 cfg_addr;
71 u8 volt_mask;
72 u8 power_mode_mask;
73 u8 power_mode_shift;
74 u8 remote_sense_addr;
75 u8 remote_sense_mask;
76 struct regulator_desc desc;
77};
78
79struct max77620_regulator_pdata {
80 struct regulator_init_data *reg_idata;
81 int active_fps_src;
82 int active_fps_pd_slot;
83 int active_fps_pu_slot;
84 int suspend_fps_src;
85 int suspend_fps_pd_slot;
86 int suspend_fps_pu_slot;
87 int current_mode;
88};
89
90struct max77620_regulator {
91 struct device *dev;
92 struct regmap *rmap;
93 struct max77620_regulator_info *rinfo[MAX77620_NUM_REGS];
94 struct max77620_regulator_pdata reg_pdata[MAX77620_NUM_REGS];
95 struct regulator_desc *rdesc[MAX77620_NUM_REGS];
96 int enable_power_mode[MAX77620_NUM_REGS];
97 int current_power_mode[MAX77620_NUM_REGS];
98 int active_fps_src[MAX77620_NUM_REGS];
99};
100
101#define fps_src_name(fps_src) \
102 (fps_src == MAX77620_FPS_SRC_0 ? "FPS_SRC_0" : \
103 fps_src == MAX77620_FPS_SRC_1 ? "FPS_SRC_1" : \
104 fps_src == MAX77620_FPS_SRC_2 ? "FPS_SRC_2" : "FPS_SRC_NONE")
105
106static int max77620_regulator_get_fps_src(struct max77620_regulator *pmic,
107 int id)
108{
109 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
110 unsigned int val;
111 int ret;
112
113 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
114 if (ret < 0) {
115 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
116 rinfo->fps_addr, ret);
117 return ret;
118 }
119
120 return (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
121}
122
123static int max77620_regulator_set_fps_src(struct max77620_regulator *pmic,
124 int fps_src, int id)
125{
126 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
127 unsigned int val;
128 int ret;
129
130 switch (fps_src) {
131 case MAX77620_FPS_SRC_0:
132 case MAX77620_FPS_SRC_1:
133 case MAX77620_FPS_SRC_2:
134 case MAX77620_FPS_SRC_NONE:
135 break;
136
137 case MAX77620_FPS_SRC_DEF:
138 ret = regmap_read(pmic->rmap, rinfo->fps_addr, &val);
139 if (ret < 0) {
140 dev_err(pmic->dev, "Reg 0x%02x read failed %d\n",
141 rinfo->fps_addr, ret);
142 return ret;
143 }
144 ret = (val & MAX77620_FPS_SRC_MASK) >> MAX77620_FPS_SRC_SHIFT;
145 pmic->active_fps_src[id] = ret;
146 return 0;
147
148 default:
149 dev_err(pmic->dev, "Invalid FPS %d for regulator %d\n",
150 fps_src, id);
151 return -EINVAL;
152 }
153
154 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
155 MAX77620_FPS_SRC_MASK,
156 fps_src << MAX77620_FPS_SRC_SHIFT);
157 if (ret < 0) {
158 dev_err(pmic->dev, "Reg 0x%02x update failed %d\n",
159 rinfo->fps_addr, ret);
160 return ret;
161 }
162 pmic->active_fps_src[id] = fps_src;
163
164 return 0;
165}
166
167static int max77620_regulator_set_fps_slots(struct max77620_regulator *pmic,
168 int id, bool is_suspend)
169{
170 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
171 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
172 unsigned int val = 0;
173 unsigned int mask = 0;
174 int pu = rpdata->active_fps_pu_slot;
175 int pd = rpdata->active_fps_pd_slot;
176 int ret = 0;
177
178 if (is_suspend) {
179 pu = rpdata->suspend_fps_pu_slot;
180 pd = rpdata->suspend_fps_pd_slot;
181 }
182
183 /* FPS power up period setting */
184 if (pu >= 0) {
185 val |= (pu << MAX77620_FPS_PU_PERIOD_SHIFT);
186 mask |= MAX77620_FPS_PU_PERIOD_MASK;
187 }
188
189 /* FPS power down period setting */
190 if (pd >= 0) {
191 val |= (pd << MAX77620_FPS_PD_PERIOD_SHIFT);
192 mask |= MAX77620_FPS_PD_PERIOD_MASK;
193 }
194
195 if (mask) {
196 ret = regmap_update_bits(pmic->rmap, rinfo->fps_addr,
197 mask, val);
198 if (ret < 0) {
199 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
200 rinfo->fps_addr, ret);
201 return ret;
202 }
203 }
204
205 return ret;
206}
207
208static int max77620_regulator_set_power_mode(struct max77620_regulator *pmic,
209 int power_mode, int id)
210{
211 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
212 u8 mask = rinfo->power_mode_mask;
213 u8 shift = rinfo->power_mode_shift;
214 u8 addr;
215 int ret;
216
217 switch (rinfo->type) {
218 case MAX77620_REGULATOR_TYPE_SD:
219 addr = rinfo->cfg_addr;
220 break;
221 default:
222 addr = rinfo->volt_addr;
223 break;
224 }
225
226 ret = regmap_update_bits(pmic->rmap, addr, mask, power_mode << shift);
227 if (ret < 0) {
228 dev_err(pmic->dev, "Regulator %d mode set failed: %d\n",
229 id, ret);
230 return ret;
231 }
232 pmic->current_power_mode[id] = power_mode;
233
234 return ret;
235}
236
237static int max77620_regulator_get_power_mode(struct max77620_regulator *pmic,
238 int id)
239{
240 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
241 unsigned int val, addr;
242 u8 mask = rinfo->power_mode_mask;
243 u8 shift = rinfo->power_mode_shift;
244 int ret;
245
246 switch (rinfo->type) {
247 case MAX77620_REGULATOR_TYPE_SD:
248 addr = rinfo->cfg_addr;
249 break;
250 default:
251 addr = rinfo->volt_addr;
252 break;
253 }
254
255 ret = regmap_read(pmic->rmap, addr, &val);
256 if (ret < 0) {
257 dev_err(pmic->dev, "Regulator %d: Reg 0x%02x read failed: %d\n",
258 id, addr, ret);
259 return ret;
260 }
261
262 return (val & mask) >> shift;
263}
264
265static int max77620_read_slew_rate(struct max77620_regulator *pmic, int id)
266{
267 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
268 unsigned int rval;
269 int slew_rate;
270 int ret;
271
272 switch (rinfo->type) {
273 case MAX77620_REGULATOR_TYPE_SD:
274 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &rval);
275 if (ret < 0) {
276 dev_err(pmic->dev, "Register 0x%02x read failed: %d\n",
277 rinfo->cfg_addr, ret);
278 return ret;
279 }
280
281 slew_rate = (rval >> MAX77620_SD_SR_SHIFT) & 0x3;
282 switch (slew_rate) {
283 case 0:
284 slew_rate = 13750;
285 break;
286 case 1:
287 slew_rate = 27500;
288 break;
289 case 2:
290 slew_rate = 55000;
291 break;
292 case 3:
293 slew_rate = 100000;
294 break;
295 }
296 rinfo->desc.ramp_delay = slew_rate;
297 break;
298 default:
299 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &rval);
300 if (ret < 0) {
301 dev_err(pmic->dev, "Register 0x%02x read failed: %d\n",
302 rinfo->cfg_addr, ret);
303 return ret;
304 }
305 slew_rate = rval & 0x1;
306 switch (slew_rate) {
307 case 0:
308 slew_rate = 100000;
309 break;
310 case 1:
311 slew_rate = 5000;
312 break;
313 }
314 rinfo->desc.ramp_delay = slew_rate;
315 break;
316 }
317
318 return 0;
319}
320
321static int max77620_init_pmic(struct max77620_regulator *pmic, int id)
322{
323 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
324 int ret;
325
326 /* Update power mode */
327 ret = max77620_regulator_get_power_mode(pmic, id);
328 if (ret < 0)
329 return ret;
330
331 pmic->current_power_mode[id] = ret;
332 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
333
334 if (rpdata->active_fps_src == MAX77620_FPS_SRC_DEF) {
335 ret = max77620_regulator_get_fps_src(pmic, id);
336 if (ret < 0)
337 return ret;
338 rpdata->active_fps_src = ret;
339 }
340
341 /* If rails are externally control of FPS then enable it always. */
342 if (rpdata->active_fps_src == MAX77620_FPS_SRC_NONE) {
343 ret = max77620_regulator_set_power_mode(pmic,
344 pmic->enable_power_mode[id], id);
345 if (ret < 0)
346 return ret;
347 } else {
348 if (pmic->current_power_mode[id] !=
349 pmic->enable_power_mode[id]) {
350 ret = max77620_regulator_set_power_mode(pmic,
351 pmic->enable_power_mode[id], id);
352 if (ret < 0)
353 return ret;
354 }
355 }
356
357 ret = max77620_regulator_set_fps_src(pmic, rpdata->active_fps_src, id);
358 if (ret < 0)
359 return ret;
360
361 ret = max77620_regulator_set_fps_slots(pmic, id, false);
362 if (ret < 0)
363 return ret;
364
365 return 0;
366}
367
368static int max77620_regulator_enable(struct regulator_dev *rdev)
369{
370 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
371 int id = rdev_get_id(rdev);
372
373 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
374 return 0;
375
376 return max77620_regulator_set_power_mode(pmic,
377 pmic->enable_power_mode[id], id);
378}
379
380static int max77620_regulator_disable(struct regulator_dev *rdev)
381{
382 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
383 int id = rdev_get_id(rdev);
384
385 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
386 return 0;
387
388 return max77620_regulator_set_power_mode(pmic,
389 MAX77620_POWER_MODE_DISABLE, id);
390}
391
392static int max77620_regulator_is_enabled(struct regulator_dev *rdev)
393{
394 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
395 int id = rdev_get_id(rdev);
396 int ret = 1;
397
398 if (pmic->active_fps_src[id] != MAX77620_FPS_SRC_NONE)
399 return 1;
400
401 ret = max77620_regulator_get_power_mode(pmic, id);
402 if (ret < 0)
403 return ret;
404
405 if (ret != MAX77620_POWER_MODE_DISABLE)
406 return 1;
407
408 return 0;
409}
410
411static int max77620_regulator_set_mode(struct regulator_dev *rdev,
412 unsigned int mode)
413{
414 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
415 int id = rdev_get_id(rdev);
416 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
417 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[id];
418 bool fpwm = false;
419 int power_mode;
420 int ret;
421 u8 val;
422
423 switch (mode) {
424 case REGULATOR_MODE_FAST:
425 fpwm = true;
426 power_mode = MAX77620_POWER_MODE_NORMAL;
427 break;
428
429 case REGULATOR_MODE_NORMAL:
430 power_mode = MAX77620_POWER_MODE_NORMAL;
431 break;
432
433 case REGULATOR_MODE_IDLE:
434 power_mode = MAX77620_POWER_MODE_LPM;
435 break;
436
437 default:
438 dev_err(pmic->dev, "Regulator %d mode %d is invalid\n",
439 id, mode);
440 return -EINVAL;
441 }
442
443 if (rinfo->type != MAX77620_REGULATOR_TYPE_SD)
444 goto skip_fpwm;
445
446 val = (fpwm) ? MAX77620_SD_FPWM_MASK : 0;
447 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr,
448 MAX77620_SD_FPWM_MASK, val);
449 if (ret < 0) {
450 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
451 rinfo->cfg_addr, ret);
452 return ret;
453 }
454 rpdata->current_mode = mode;
455
456skip_fpwm:
457 ret = max77620_regulator_set_power_mode(pmic, power_mode, id);
458 if (ret < 0)
459 return ret;
460
461 pmic->enable_power_mode[id] = power_mode;
462
463 return 0;
464}
465
466static unsigned int max77620_regulator_get_mode(struct regulator_dev *rdev)
467{
468 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
469 int id = rdev_get_id(rdev);
470 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
471 int fpwm = 0;
472 int ret;
473 int pm_mode, reg_mode;
474 unsigned int val;
475
476 ret = max77620_regulator_get_power_mode(pmic, id);
477 if (ret < 0)
478 return 0;
479
480 pm_mode = ret;
481
482 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
483 ret = regmap_read(pmic->rmap, rinfo->cfg_addr, &val);
484 if (ret < 0) {
485 dev_err(pmic->dev, "Reg 0x%02x read failed: %d\n",
486 rinfo->cfg_addr, ret);
487 return ret;
488 }
489 fpwm = !!(val & MAX77620_SD_FPWM_MASK);
490 }
491
492 switch (pm_mode) {
493 case MAX77620_POWER_MODE_NORMAL:
494 case MAX77620_POWER_MODE_DISABLE:
495 if (fpwm)
496 reg_mode = REGULATOR_MODE_FAST;
497 else
498 reg_mode = REGULATOR_MODE_NORMAL;
499 break;
500 case MAX77620_POWER_MODE_LPM:
501 case MAX77620_POWER_MODE_GLPM:
502 reg_mode = REGULATOR_MODE_IDLE;
503 break;
504 default:
505 return 0;
506 }
507
508 return reg_mode;
509}
510
511static int max77620_regulator_set_ramp_delay(struct regulator_dev *rdev,
512 int ramp_delay)
513{
514 struct max77620_regulator *pmic = rdev_get_drvdata(rdev);
515 int id = rdev_get_id(rdev);
516 struct max77620_regulator_info *rinfo = pmic->rinfo[id];
517 int ret, val;
518 u8 mask;
519
520 if (rinfo->type == MAX77620_REGULATOR_TYPE_SD) {
521 if (ramp_delay <= 13750)
522 val = 0;
523 else if (ramp_delay <= 27500)
524 val = 1;
525 else if (ramp_delay <= 55000)
526 val = 2;
527 else
528 val = 3;
529 val <<= MAX77620_SD_SR_SHIFT;
530 mask = MAX77620_SD_SR_MASK;
531 } else {
532 if (ramp_delay <= 5000)
533 val = 1;
534 else
535 val = 0;
536 mask = MAX77620_LDO_SLEW_RATE_MASK;
537 }
538
539 ret = regmap_update_bits(pmic->rmap, rinfo->cfg_addr, mask, val);
540 if (ret < 0)
541 dev_err(pmic->dev, "Reg 0x%02x update failed: %d\n",
542 rinfo->cfg_addr, ret);
543
544 return ret;
545}
546
547static int max77620_of_parse_cb(struct device_node *np,
548 const struct regulator_desc *desc,
549 struct regulator_config *config)
550{
551 struct max77620_regulator *pmic = config->driver_data;
552 struct max77620_regulator_pdata *rpdata = &pmic->reg_pdata[desc->id];
553 u32 pval;
554 int ret;
555
556 ret = of_property_read_u32(np, "maxim,active-fps-source", &pval);
557 rpdata->active_fps_src = (!ret) ? pval : MAX77620_FPS_SRC_DEF;
558
559 ret = of_property_read_u32(np, "maxim,active-fps-power-up-slot", &pval);
560 rpdata->active_fps_pu_slot = (!ret) ? pval : -1;
561
562 ret = of_property_read_u32(
563 np, "maxim,active-fps-power-down-slot", &pval);
564 rpdata->active_fps_pd_slot = (!ret) ? pval : -1;
565
566 ret = of_property_read_u32(np, "maxim,suspend-fps-source", &pval);
567 rpdata->suspend_fps_src = (!ret) ? pval : -1;
568
569 ret = of_property_read_u32(
570 np, "maxim,suspend-fps-power-up-slot", &pval);
571 rpdata->suspend_fps_pu_slot = (!ret) ? pval : -1;
572
573 ret = of_property_read_u32(
574 np, "maxim,suspend-fps-power-down-slot", &pval);
575 rpdata->suspend_fps_pd_slot = (!ret) ? pval : -1;
576
577 return max77620_init_pmic(pmic, desc->id);
578}
579
580static struct regulator_ops max77620_regulator_ops = {
581 .is_enabled = max77620_regulator_is_enabled,
582 .enable = max77620_regulator_enable,
583 .disable = max77620_regulator_disable,
584 .list_voltage = regulator_list_voltage_linear,
585 .map_voltage = regulator_map_voltage_linear,
586 .get_voltage_sel = regulator_get_voltage_sel_regmap,
587 .set_voltage_sel = regulator_set_voltage_sel_regmap,
588 .set_mode = max77620_regulator_set_mode,
589 .get_mode = max77620_regulator_get_mode,
590 .set_ramp_delay = max77620_regulator_set_ramp_delay,
591 .set_voltage_time_sel = regulator_set_voltage_time_sel,
592};
593
594#define MAX77620_SD_CNF2_ROVS_EN_NONE 0
595#define RAIL_SD(_id, _name, _sname, _volt_mask, _min_uV, _max_uV, \
596 _step_uV, _rs_add, _rs_mask) \
597 [MAX77620_REGULATOR_ID_##_id] = { \
598 .type = MAX77620_REGULATOR_TYPE_SD, \
599 .volt_mask = MAX77620_##_volt_mask##_VOLT_MASK, \
600 .volt_addr = MAX77620_REG_##_id, \
601 .cfg_addr = MAX77620_REG_##_id##_CFG, \
602 .fps_addr = MAX77620_REG_FPS_##_id, \
603 .remote_sense_addr = _rs_add, \
604 .remote_sense_mask = MAX77620_SD_CNF2_ROVS_EN_##_rs_mask, \
605 .min_uV = _min_uV, \
606 .max_uV = _max_uV, \
607 .step_uV = _step_uV, \
608 .power_mode_mask = MAX77620_SD_POWER_MODE_MASK, \
609 .power_mode_shift = MAX77620_SD_POWER_MODE_SHIFT, \
610 .desc = { \
611 .name = max77620_rails(_name), \
612 .of_match = of_match_ptr(#_name), \
613 .regulators_node = of_match_ptr("regulators"), \
614 .of_parse_cb = max77620_of_parse_cb, \
615 .supply_name = _sname, \
616 .id = MAX77620_REGULATOR_ID_##_id, \
617 .ops = &max77620_regulator_ops, \
618 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
619 .min_uV = _min_uV, \
620 .uV_step = _step_uV, \
621 .enable_time = 500, \
622 .vsel_mask = MAX77620_##_volt_mask##_VOLT_MASK, \
623 .vsel_reg = MAX77620_REG_##_id, \
624 .type = REGULATOR_VOLTAGE, \
625 }, \
626 }
627
628#define RAIL_LDO(_id, _name, _sname, _type, _min_uV, _max_uV, _step_uV) \
629 [MAX77620_REGULATOR_ID_##_id] = { \
630 .type = MAX77620_REGULATOR_TYPE_LDO_##_type, \
631 .volt_mask = MAX77620_LDO_VOLT_MASK, \
632 .volt_addr = MAX77620_REG_##_id##_CFG, \
633 .cfg_addr = MAX77620_REG_##_id##_CFG2, \
634 .fps_addr = MAX77620_REG_FPS_##_id, \
635 .remote_sense_addr = 0xFF, \
636 .min_uV = _min_uV, \
637 .max_uV = _max_uV, \
638 .step_uV = _step_uV, \
639 .power_mode_mask = MAX77620_LDO_POWER_MODE_MASK, \
640 .power_mode_shift = MAX77620_LDO_POWER_MODE_SHIFT, \
641 .desc = { \
642 .name = max77620_rails(_name), \
643 .of_match = of_match_ptr(#_name), \
644 .regulators_node = of_match_ptr("regulators"), \
645 .of_parse_cb = max77620_of_parse_cb, \
646 .supply_name = _sname, \
647 .id = MAX77620_REGULATOR_ID_##_id, \
648 .ops = &max77620_regulator_ops, \
649 .n_voltages = ((_max_uV - _min_uV) / _step_uV) + 1, \
650 .min_uV = _min_uV, \
651 .uV_step = _step_uV, \
652 .enable_time = 500, \
653 .vsel_mask = MAX77620_LDO_VOLT_MASK, \
654 .vsel_reg = MAX77620_REG_##_id##_CFG, \
655 .type = REGULATOR_VOLTAGE, \
656 }, \
657 }
658
659static struct max77620_regulator_info max77620_regs_info[MAX77620_NUM_REGS] = {
660 RAIL_SD(SD0, sd0, "in-sd0", SD0, 600000, 1400000, 12500, 0x22, SD0),
661 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 1550000, 12500, 0x22, SD1),
662 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
663 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
664 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
665
666 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
667 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
668 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
669 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
670 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
671 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
672 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
673 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
674 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
675};
676
677static struct max77620_regulator_info max20024_regs_info[MAX77620_NUM_REGS] = {
678 RAIL_SD(SD0, sd0, "in-sd0", SD0, 800000, 1587500, 12500, 0x22, SD0),
679 RAIL_SD(SD1, sd1, "in-sd1", SD1, 600000, 3387500, 12500, 0x22, SD1),
680 RAIL_SD(SD2, sd2, "in-sd2", SDX, 600000, 3787500, 12500, 0xFF, NONE),
681 RAIL_SD(SD3, sd3, "in-sd3", SDX, 600000, 3787500, 12500, 0xFF, NONE),
682 RAIL_SD(SD4, sd4, "in-sd4", SDX, 600000, 3787500, 12500, 0xFF, NONE),
683
684 RAIL_LDO(LDO0, ldo0, "in-ldo0-1", N, 800000, 2375000, 25000),
685 RAIL_LDO(LDO1, ldo1, "in-ldo0-1", N, 800000, 2375000, 25000),
686 RAIL_LDO(LDO2, ldo2, "in-ldo2", P, 800000, 3950000, 50000),
687 RAIL_LDO(LDO3, ldo3, "in-ldo3-5", P, 800000, 3950000, 50000),
688 RAIL_LDO(LDO4, ldo4, "in-ldo4-6", P, 800000, 1587500, 12500),
689 RAIL_LDO(LDO5, ldo5, "in-ldo3-5", P, 800000, 3950000, 50000),
690 RAIL_LDO(LDO6, ldo6, "in-ldo4-6", P, 800000, 3950000, 50000),
691 RAIL_LDO(LDO7, ldo7, "in-ldo7-8", N, 800000, 3950000, 50000),
692 RAIL_LDO(LDO8, ldo8, "in-ldo7-8", N, 800000, 3950000, 50000),
693};
694
695static int max77620_regulator_probe(struct platform_device *pdev)
696{
697 struct max77620_chip *max77620_chip = dev_get_drvdata(pdev->dev.parent);
698 struct max77620_regulator_info *rinfo;
699 struct device *dev = &pdev->dev;
700 struct regulator_config config = { };
701 struct max77620_regulator *pmic;
702 int ret = 0;
703 int id;
704
705 pmic = devm_kzalloc(dev, sizeof(*pmic), GFP_KERNEL);
706 if (!pmic)
707 return -ENOMEM;
708
709 platform_set_drvdata(pdev, pmic);
710 pmic->dev = dev;
711 pmic->rmap = max77620_chip->rmap;
712 if (!dev->of_node)
713 dev->of_node = pdev->dev.parent->of_node;
714
715 switch (max77620_chip->chip_id) {
716 case MAX77620:
717 rinfo = max77620_regs_info;
718 break;
719 default:
720 rinfo = max20024_regs_info;
721 break;
722 }
723
724 config.regmap = pmic->rmap;
725 config.dev = dev;
726 config.driver_data = pmic;
727
728 for (id = 0; id < MAX77620_NUM_REGS; id++) {
729 struct regulator_dev *rdev;
730 struct regulator_desc *rdesc;
731
732 if ((max77620_chip->chip_id == MAX77620) &&
733 (id == MAX77620_REGULATOR_ID_SD4))
734 continue;
735
736 rdesc = &rinfo[id].desc;
737 pmic->rinfo[id] = &max77620_regs_info[id];
738 pmic->enable_power_mode[id] = MAX77620_POWER_MODE_NORMAL;
739 pmic->rdesc[id] = rdesc;
740
741 ret = max77620_read_slew_rate(pmic, id);
742 if (ret < 0)
743 return ret;
744
745 rdev = devm_regulator_register(dev, rdesc, &config);
746 if (IS_ERR(rdev)) {
747 ret = PTR_ERR(rdev);
748 dev_err(dev, "Regulator registration %s failed: %d\n",
749 rdesc->name, ret);
750 return ret;
751 }
752 }
753
754 return 0;
755}
756
757#ifdef CONFIG_PM_SLEEP
758static int max77620_regulator_suspend(struct device *dev)
759{
760 struct max77620_regulator *pmic = dev_get_drvdata(dev);
761 struct max77620_regulator_pdata *reg_pdata;
762 int id;
763
764 for (id = 0; id < MAX77620_NUM_REGS; id++) {
765 reg_pdata = &pmic->reg_pdata[id];
766
767 max77620_regulator_set_fps_slots(pmic, id, true);
768 if (reg_pdata->suspend_fps_src < 0)
769 continue;
770
771 max77620_regulator_set_fps_src(pmic, reg_pdata->suspend_fps_src,
772 id);
773 }
774
775 return 0;
776}
777
778static int max77620_regulator_resume(struct device *dev)
779{
780 struct max77620_regulator *pmic = dev_get_drvdata(dev);
781 struct max77620_regulator_pdata *reg_pdata;
782 int id;
783
784 for (id = 0; id < MAX77620_NUM_REGS; id++) {
785 reg_pdata = &pmic->reg_pdata[id];
786
787 max77620_regulator_set_fps_slots(pmic, id, false);
788 if (reg_pdata->active_fps_src < 0)
789 continue;
790 max77620_regulator_set_fps_src(pmic, reg_pdata->active_fps_src,
791 id);
792 }
793
794 return 0;
795}
796#endif
797
798static const struct dev_pm_ops max77620_regulator_pm_ops = {
799 SET_SYSTEM_SLEEP_PM_OPS(max77620_regulator_suspend,
800 max77620_regulator_resume)
801};
802
803static const struct platform_device_id max77620_regulator_devtype[] = {
804 { .name = "max77620-pmic", },
805 { .name = "max20024-pmic", },
806 {},
807};
808MODULE_DEVICE_TABLE(platform, max77620_regulator_devtype);
809
810static struct platform_driver max77620_regulator_driver = {
811 .probe = max77620_regulator_probe,
812 .id_table = max77620_regulator_devtype,
813 .driver = {
814 .name = "max77620-pmic",
815 .pm = &max77620_regulator_pm_ops,
816 },
817};
818
819module_platform_driver(max77620_regulator_driver);
820
821MODULE_DESCRIPTION("MAX77620/MAX20024 regulator driver");
822MODULE_AUTHOR("Mallikarjun Kasoju <mkasoju@nvidia.com>");
823MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
824MODULE_ALIAS("platform:max77620-pmic");
825MODULE_LICENSE("GPL v2");
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-14 17:02:11 -0400