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