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 
35 enum 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 */
54 enum max77620_regulator_type {
55 	MAX77620_REGULATOR_TYPE_SD,
56 	MAX77620_REGULATOR_TYPE_LDO_N,
57 	MAX77620_REGULATOR_TYPE_LDO_P,
58 };
59 
60 struct 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 
72 struct 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 
84 struct 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 
99 static 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 
116 static 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 
163 static 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 
207 static 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 
236 static 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 
264 static 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 
314 static 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 
351 static 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 
386 static 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 
442 static 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 
454 static 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 
466 static 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 
485 static 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 
530 skip_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 
540 static 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 
585 static 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 
602 static 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 
644 static 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 
726 static 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 
743 static 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 
761 static 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 
779 static 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
859 static 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 
879 static 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 
901 static const struct dev_pm_ops max77620_regulator_pm_ops = {
902 	SET_SYSTEM_SLEEP_PM_OPS(max77620_regulator_suspend,
903 				max77620_regulator_resume)
904 };
905 
906 static const struct platform_device_id max77620_regulator_devtype[] = {
907 	{ .name = "max77620-pmic", },
908 	{ .name = "max20024-pmic", },
909 	{ .name = "max77663-pmic", },
910 	{},
911 };
912 MODULE_DEVICE_TABLE(platform, max77620_regulator_devtype);
913 
914 static struct platform_driver max77620_regulator_driver = {
915 	.probe = max77620_regulator_probe,
916 	.id_table = max77620_regulator_devtype,
917 	.driver = {
918 		.name = "max77620-pmic",
919 		.pm = &max77620_regulator_pm_ops,
920 	},
921 };
922 
923 module_platform_driver(max77620_regulator_driver);
924 
925 MODULE_DESCRIPTION("MAX77620/MAX20024 regulator driver");
926 MODULE_AUTHOR("Mallikarjun Kasoju <mkasoju@nvidia.com>");
927 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
928 MODULE_LICENSE("GPL v2");
929