xref: /linux/drivers/regulator/mt6363-regulator.c (revision 7904338c38426d72c5f7cd9402cb9a20232a7af5)
1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Copyright (c) 2024 MediaTek Inc.
4 // Copyright (c) 2025 Collabora Ltd
5 //                    AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
6 
7 #include <linux/delay.h>
8 #include <linux/devm-helpers.h>
9 #include <linux/err.h>
10 #include <linux/interrupt.h>
11 #include <linux/irq.h>
12 #include <linux/irqdomain.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_device.h>
17 #include <linux/of_irq.h>
18 #include <linux/platform_device.h>
19 #include <linux/regmap.h>
20 #include <linux/spmi.h>
21 
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24 #include <linux/regulator/mt6363-regulator.h>
25 #include <linux/regulator/of_regulator.h>
26 
27 #define MT6363_REGULATOR_MODE_NORMAL	0
28 #define MT6363_REGULATOR_MODE_FCCM	1
29 #define MT6363_REGULATOR_MODE_LP	2
30 #define MT6363_REGULATOR_MODE_ULP	3
31 
32 #define EN_SET_OFFSET			0x1
33 #define EN_CLR_OFFSET			0x2
34 #define OP_CFG_OFFSET			0x5
35 
36 #define NORMAL_OP_CFG			0x10
37 #define NORMAL_OP_EN			0x800000
38 
39 #define OC_IRQ_ENABLE_DELAY_MS		10
40 
41 /* Unlock keys for TMA and BUCK_TOP */
42 #define MT6363_TMA_UNLOCK_VALUE		0x9c9c
43 #define MT6363_BUCK_TOP_UNLOCK_VALUE	0x5543
44 
45 enum {
46 	MT6363_ID_VBUCK1,
47 	MT6363_ID_VBUCK2,
48 	MT6363_ID_VBUCK3,
49 	MT6363_ID_VBUCK4,
50 	MT6363_ID_VBUCK5,
51 	MT6363_ID_VBUCK6,
52 	MT6363_ID_VBUCK7,
53 	MT6363_ID_VS1,
54 	MT6363_ID_VS2,
55 	MT6363_ID_VS3,
56 	MT6363_ID_VA12_1,
57 	MT6363_ID_VA12_2,
58 	MT6363_ID_VA15,
59 	MT6363_ID_VAUX18,
60 	MT6363_ID_VCN13,
61 	MT6363_ID_VCN15,
62 	MT6363_ID_VEMC,
63 	MT6363_ID_VIO075,
64 	MT6363_ID_VIO18,
65 	MT6363_ID_VM18,
66 	MT6363_ID_VSRAM_APU,
67 	MT6363_ID_VSRAM_CPUB,
68 	MT6363_ID_VSRAM_CPUM,
69 	MT6363_ID_VSRAM_CPUL,
70 	MT6363_ID_VSRAM_DIGRF,
71 	MT6363_ID_VSRAM_MDFE,
72 	MT6363_ID_VSRAM_MODEM,
73 	MT6363_ID_VRF09,
74 	MT6363_ID_VRF12,
75 	MT6363_ID_VRF13,
76 	MT6363_ID_VRF18,
77 	MT6363_ID_VRFIO18,
78 	MT6363_ID_VTREF18,
79 	MT6363_ID_VUFS12,
80 	MT6363_ID_VUFS18,
81 };
82 
83 /**
84  * struct mt6363_regulator_info - MT6363 regulators information
85  * @desc: Regulator description structure
86  * @lp_mode_reg: Low Power mode register (normal/idle)
87  * @lp_mode_mask: Low Power mode regulator mask
88  * @hw_lp_mode_reg: Hardware voted Low Power mode register (normal/idle)
89  * @hw_lp_mode_mask: Hardware voted Low Power mode regulator mask
90  * @modeset_reg: AUTO/PWM mode register
91  * @modeset_mask: AUTO/PWM regulator mask
92  * @lp_imax_uA: Maximum load current (microamps), for Low Power mode only
93  * @op_en_reg: Operation mode enablement register
94  * @orig_op_en: Backup of a regulator's operation mode enablement register
95  * @orig_op_cfg: Backup of a regulator's operation mode configuration register
96  * @oc_work: Delayed work for enabling overcurrent IRQ
97  * @hwirq: PMIC-Internal HW Interrupt for overcurrent event
98  * @virq: Mapped Interrupt for overcurrent event
99  */
100 struct mt6363_regulator_info {
101 	struct regulator_desc desc;
102 	u16 lp_mode_reg;
103 	u16 lp_mode_mask;
104 	u16 hw_lp_mode_reg;
105 	u16 hw_lp_mode_mask;
106 	u16 modeset_reg;
107 	u16 modeset_mask;
108 	int lp_imax_uA;
109 	u16 op_en_reg;
110 	u32 orig_op_en;
111 	u8 orig_op_cfg;
112 	struct delayed_work oc_work;
113 	u8 hwirq;
114 	int virq;
115 };
116 
117 #define MT6363_BUCK(match, vreg, min, max, step, en_reg, lp_reg,	\
118 		    mset_reg, ocp_intn)					\
119 [MT6363_ID_##vreg] = {							\
120 	.desc = {							\
121 		.name = match,						\
122 		.supply_name = "vsys-"match,				\
123 		.of_match = of_match_ptr(match),			\
124 		.ops = &mt6363_vreg_setclr_ops,				\
125 		.type = REGULATOR_VOLTAGE,				\
126 		.id = MT6363_ID_##vreg,					\
127 		.owner = THIS_MODULE,					\
128 		.n_voltages = (max - min) / step + 1,			\
129 		.min_uV = min,						\
130 		.uV_step = step,					\
131 		.enable_reg = en_reg,					\
132 		.enable_mask = BIT(MT6363_RG_BUCK_##vreg##_EN_BIT),	\
133 		.vsel_reg = MT6363_RG_BUCK_##vreg##_VOSEL_ADDR,		\
134 		.vsel_mask = MT6363_RG_BUCK_##vreg##_VOSEL_MASK,	\
135 		.of_map_mode = mt6363_map_mode,				\
136 	},								\
137 	.lp_mode_reg = lp_reg,						\
138 	.lp_mode_mask = BIT(MT6363_RG_BUCK_##vreg##_LP_BIT),		\
139 	.hw_lp_mode_reg = MT6363_BUCK_##vreg##_HW_LP_MODE,		\
140 	.hw_lp_mode_mask = 0xc,						\
141 	.modeset_reg = mset_reg,					\
142 	.modeset_mask = BIT(MT6363_RG_##vreg##_FCCM_BIT),		\
143 	.lp_imax_uA = 100000,						\
144 	.op_en_reg = MT6363_BUCK_##vreg##_OP_EN_0,			\
145 	.hwirq = ocp_intn,						\
146 }
147 
148 #define MT6363_LDO_LINEAR_OPS(match, vreg, in_sup, vops, min, max,	\
149 			      step, en_reg, lp_reg, ocp_intn)		\
150 [MT6363_ID_##vreg] = {							\
151 	.desc = {							\
152 		.name = match,						\
153 		.supply_name = in_sup,					\
154 		.of_match = of_match_ptr(match),			\
155 		.ops = &vops,						\
156 		.type = REGULATOR_VOLTAGE,				\
157 		.id = MT6363_ID_##vreg,					\
158 		.owner = THIS_MODULE,					\
159 		.n_voltages = (max - min) / step + 1,			\
160 		.min_uV = min,						\
161 		.uV_step = step,					\
162 		.enable_reg = en_reg,					\
163 		.enable_mask = BIT(MT6363_RG_LDO_##vreg##_EN_BIT),	\
164 		.vsel_reg = MT6363_RG_LDO_##vreg##_VOSEL_ADDR,		\
165 		.vsel_mask = MT6363_RG_LDO_##vreg##_VOSEL_MASK,		\
166 		.of_map_mode = mt6363_map_mode,				\
167 	},								\
168 	.lp_mode_reg = lp_reg,						\
169 	.lp_mode_mask = BIT(MT6363_RG_LDO_##vreg##_LP_BIT),		\
170 	.hw_lp_mode_reg = MT6363_LDO_##vreg##_HW_LP_MODE,		\
171 	.hw_lp_mode_mask = 0x4,						\
172 	.hwirq = ocp_intn,						\
173 }
174 
175 #define MT6363_LDO_L_SC(match, vreg, inp, min, max, step, buck_reg,	\
176 			ocp_intn)					\
177 	MT6363_LDO_LINEAR_OPS(match, vreg, inp, mt6363_vreg_setclr_ops,	\
178 			      min, max, step,				\
179 			      MT6363_RG_##buck_reg##_EN_ADDR,		\
180 			      MT6363_RG_##buck_reg##_LP_ADDR, ocp_intn)
181 
182 #define MT6363_LDO_L(match, vreg, inp, min, max, step, ocp_intn)	\
183 	MT6363_LDO_LINEAR_OPS(match, vreg, inp, mt6363_ldo_linear_ops,	\
184 			      min, max, step,				\
185 			      MT6363_RG_LDO_##vreg##_ADDR,		\
186 			      MT6363_RG_LDO_##vreg##_ADDR, ocp_intn)
187 
188 #define MT6363_LDO_LINEAR_CAL_OPS(match, vreg, in_sup, vops, vrnum,	\
189 				  ocp_intn)				\
190 [MT6363_ID_##vreg] = {							\
191 	.desc = {							\
192 		.name = match,						\
193 		.supply_name = in_sup,					\
194 		.of_match = of_match_ptr(match),			\
195 		.ops = &vops,						\
196 		.type = REGULATOR_VOLTAGE,				\
197 		.id = MT6363_ID_##vreg,					\
198 		.owner = THIS_MODULE,					\
199 		.n_voltages = ARRAY_SIZE(ldo_volt_ranges##vrnum) * 11,	\
200 		.linear_ranges = ldo_volt_ranges##vrnum,		\
201 		.n_linear_ranges = ARRAY_SIZE(ldo_volt_ranges##vrnum),	\
202 		.linear_range_selectors_bitfield = ldos_cal_selectors,	\
203 		.enable_reg = MT6363_RG_LDO_##vreg##_ADDR,		\
204 		.enable_mask = BIT(MT6363_RG_LDO_##vreg##_EN_BIT),	\
205 		.vsel_reg = MT6363_RG_##vreg##_VOCAL_ADDR,		\
206 		.vsel_mask = MT6363_RG_##vreg##_VOCAL_MASK,		\
207 		.vsel_range_reg = MT6363_RG_##vreg##_VOSEL_ADDR,	\
208 		.vsel_range_mask = MT6363_RG_##vreg##_VOSEL_MASK,	\
209 		.of_map_mode = mt6363_map_mode,				\
210 	},								\
211 	.lp_mode_reg = MT6363_RG_LDO_##vreg##_ADDR,			\
212 	.lp_mode_mask = BIT(MT6363_RG_LDO_##vreg##_LP_BIT),		\
213 	.hw_lp_mode_reg = MT6363_LDO_##vreg##_HW_LP_MODE,		\
214 	.hw_lp_mode_mask = 0x4,						\
215 	.lp_imax_uA = 10000,						\
216 	.op_en_reg = MT6363_LDO_##vreg##_OP_EN0,			\
217 	.hwirq = ocp_intn,						\
218 }
219 
220 #define MT6363_LDO_VT(match, vreg, inp, vranges_num, ocp_intn)		\
221 	MT6363_LDO_LINEAR_CAL_OPS(match, vreg, inp, mt6363_ldo_vtable_ops,\
222 				  vranges_num, ocp_intn)
223 
224 static const unsigned int ldos_cal_selectors[] = {
225 	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
226 };
227 
228 static const struct linear_range ldo_volt_ranges0[] = {
229 	REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000),
230 	REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000),
231 	REGULATOR_LINEAR_RANGE(1500000, 0, 10, 10000),
232 	REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000),
233 	REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000),
234 	REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000),
235 	REGULATOR_LINEAR_RANGE(2500000, 0, 10, 10000),
236 	REGULATOR_LINEAR_RANGE(2600000, 0, 10, 10000),
237 	REGULATOR_LINEAR_RANGE(2700000, 0, 10, 10000),
238 	REGULATOR_LINEAR_RANGE(2800000, 0, 10, 10000),
239 	REGULATOR_LINEAR_RANGE(2900000, 0, 10, 10000),
240 	REGULATOR_LINEAR_RANGE(3000000, 0, 10, 10000),
241 	REGULATOR_LINEAR_RANGE(3100000, 0, 10, 10000),
242 	REGULATOR_LINEAR_RANGE(3300000, 0, 10, 10000),
243 	REGULATOR_LINEAR_RANGE(3400000, 0, 10, 10000),
244 	REGULATOR_LINEAR_RANGE(3500000, 0, 10, 10000)
245 };
246 
247 static const struct linear_range ldo_volt_ranges1[] = {
248 	REGULATOR_LINEAR_RANGE(900000, 0, 10, 10000),
249 	REGULATOR_LINEAR_RANGE(1000000, 0, 10, 10000),
250 	REGULATOR_LINEAR_RANGE(1100000, 0, 10, 10000),
251 	REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000),
252 	REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000),
253 	REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000),
254 	REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000),
255 	REGULATOR_LINEAR_RANGE(1810000, 0, 10, 10000)
256 };
257 
258 static const struct linear_range ldo_volt_ranges2[] = {
259 	REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000),
260 	REGULATOR_LINEAR_RANGE(1900000, 0, 10, 10000),
261 	REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000),
262 	REGULATOR_LINEAR_RANGE(2100000, 0, 10, 10000),
263 	REGULATOR_LINEAR_RANGE(2200000, 0, 10, 10000),
264 	REGULATOR_LINEAR_RANGE(2300000, 0, 10, 10000),
265 	REGULATOR_LINEAR_RANGE(2400000, 0, 10, 10000),
266 	REGULATOR_LINEAR_RANGE(2500000, 0, 10, 10000),
267 	REGULATOR_LINEAR_RANGE(2600000, 0, 10, 10000),
268 	REGULATOR_LINEAR_RANGE(2700000, 0, 10, 10000),
269 	REGULATOR_LINEAR_RANGE(2800000, 0, 10, 10000),
270 	REGULATOR_LINEAR_RANGE(2900000, 0, 10, 10000),
271 	REGULATOR_LINEAR_RANGE(3000000, 0, 10, 10000),
272 	REGULATOR_LINEAR_RANGE(3100000, 0, 10, 10000),
273 	REGULATOR_LINEAR_RANGE(3200000, 0, 10, 10000),
274 	REGULATOR_LINEAR_RANGE(3300000, 0, 10, 10000)
275 };
276 
277 static const struct linear_range ldo_volt_ranges3[] = {
278 	REGULATOR_LINEAR_RANGE(600000, 0, 10, 10000),
279 	REGULATOR_LINEAR_RANGE(700000, 0, 10, 10000),
280 	REGULATOR_LINEAR_RANGE(800000, 0, 10, 10000),
281 	REGULATOR_LINEAR_RANGE(900000, 0, 10, 10000),
282 	REGULATOR_LINEAR_RANGE(1000000, 0, 10, 10000),
283 	REGULATOR_LINEAR_RANGE(1100000, 0, 10, 10000),
284 	REGULATOR_LINEAR_RANGE(1200000, 0, 10, 10000),
285 	REGULATOR_LINEAR_RANGE(1300000, 0, 10, 10000),
286 	REGULATOR_LINEAR_RANGE(1400000, 0, 10, 10000),
287 	REGULATOR_LINEAR_RANGE(1500000, 0, 10, 10000),
288 	REGULATOR_LINEAR_RANGE(1600000, 0, 10, 10000),
289 	REGULATOR_LINEAR_RANGE(1700000, 0, 10, 10000),
290 	REGULATOR_LINEAR_RANGE(1800000, 0, 10, 10000),
291 	REGULATOR_LINEAR_RANGE(1900000, 0, 10, 10000),
292 	REGULATOR_LINEAR_RANGE(2000000, 0, 10, 10000),
293 	REGULATOR_LINEAR_RANGE(2100000, 0, 10, 10000)
294 };
295 
296 static const struct linear_range ldo_volt_ranges4[] = {
297 	REGULATOR_LINEAR_RANGE(550000, 0, 10, 5000),
298 	REGULATOR_LINEAR_RANGE(600000, 0, 10, 5000),
299 	REGULATOR_LINEAR_RANGE(650000, 0, 10, 5000),
300 	REGULATOR_LINEAR_RANGE(700000, 0, 10, 5000),
301 	REGULATOR_LINEAR_RANGE(750000, 0, 10, 5000),
302 	REGULATOR_LINEAR_RANGE(800000, 0, 10, 5000),
303 	REGULATOR_LINEAR_RANGE(900000, 0, 10, 5000),
304 	REGULATOR_LINEAR_RANGE(950000, 0, 10, 5000),
305 	REGULATOR_LINEAR_RANGE(1000000, 0, 10, 5000),
306 	REGULATOR_LINEAR_RANGE(1050000, 0, 10, 5000),
307 	REGULATOR_LINEAR_RANGE(1100000, 0, 10, 5000),
308 	REGULATOR_LINEAR_RANGE(1150000, 0, 10, 5000),
309 	REGULATOR_LINEAR_RANGE(1700000, 0, 10, 5000),
310 	REGULATOR_LINEAR_RANGE(1750000, 0, 10, 5000),
311 	REGULATOR_LINEAR_RANGE(1800000, 0, 10, 5000),
312 	REGULATOR_LINEAR_RANGE(1850000, 0, 10, 5000)
313 };
314 
315 static const struct linear_range ldo_volt_ranges5[] = {
316 	REGULATOR_LINEAR_RANGE(600000, 0, 10, 5000),
317 	REGULATOR_LINEAR_RANGE(650000, 0, 10, 5000),
318 	REGULATOR_LINEAR_RANGE(700000, 0, 10, 5000),
319 	REGULATOR_LINEAR_RANGE(750000, 0, 10, 5000),
320 	REGULATOR_LINEAR_RANGE(800000, 0, 10, 5000)
321 };
322 
323 static int mt6363_vreg_enable_setclr(struct regulator_dev *rdev)
324 {
325 	return regmap_write(rdev->regmap, rdev->desc->enable_reg + EN_SET_OFFSET,
326 			    rdev->desc->enable_mask);
327 }
328 
329 static int mt6363_vreg_disable_setclr(struct regulator_dev *rdev)
330 {
331 	return regmap_write(rdev->regmap, rdev->desc->enable_reg + EN_CLR_OFFSET,
332 			    rdev->desc->enable_mask);
333 }
334 
335 static inline unsigned int mt6363_map_mode(unsigned int mode)
336 {
337 	switch (mode) {
338 	case MT6363_REGULATOR_MODE_NORMAL:
339 		return REGULATOR_MODE_NORMAL;
340 	case MT6363_REGULATOR_MODE_FCCM:
341 		return REGULATOR_MODE_FAST;
342 	case MT6363_REGULATOR_MODE_LP:
343 		return REGULATOR_MODE_IDLE;
344 	case MT6363_REGULATOR_MODE_ULP:
345 		return REGULATOR_MODE_STANDBY;
346 	default:
347 		return REGULATOR_MODE_INVALID;
348 	}
349 }
350 
351 static unsigned int mt6363_regulator_get_mode(struct regulator_dev *rdev)
352 {
353 	struct mt6363_regulator_info *info = rdev_get_drvdata(rdev);
354 	unsigned int val;
355 	int ret;
356 
357 	if (info->modeset_reg) {
358 		ret = regmap_read(rdev->regmap, info->modeset_reg, &val);
359 		if (ret) {
360 			dev_err(&rdev->dev, "Failed to get mt6363 mode: %d\n", ret);
361 			return ret;
362 		}
363 
364 		if (val & info->modeset_mask)
365 			return REGULATOR_MODE_FAST;
366 	} else {
367 		val = 0;
368 	}
369 
370 	ret = regmap_read(rdev->regmap, info->hw_lp_mode_reg, &val);
371 	val &= info->hw_lp_mode_mask;
372 
373 	if (ret) {
374 		dev_err(&rdev->dev, "Failed to get lp mode: %d\n", ret);
375 		return ret;
376 	}
377 
378 	if (val)
379 		return REGULATOR_MODE_IDLE;
380 	else
381 		return REGULATOR_MODE_NORMAL;
382 }
383 
384 static int mt6363_buck_unlock(struct regmap *map, bool unlock)
385 {
386 	__le16 buf = cpu_to_le16(unlock ? MT6363_BUCK_TOP_UNLOCK_VALUE : 0);
387 
388 	return regmap_bulk_write(map, MT6363_BUCK_TOP_KEY_PROT_LO, &buf, sizeof(buf));
389 }
390 
391 static int mt6363_regulator_set_mode(struct regulator_dev *rdev,
392 				     unsigned int mode)
393 {
394 	struct mt6363_regulator_info *info = rdev_get_drvdata(rdev);
395 	struct regmap *regmap = rdev->regmap;
396 	int cur_mode, ret;
397 
398 	if (!info->modeset_reg && mode == REGULATOR_MODE_FAST)
399 		return -EOPNOTSUPP;
400 
401 	switch (mode) {
402 	case REGULATOR_MODE_FAST:
403 		ret = mt6363_buck_unlock(regmap, true);
404 		if (ret)
405 			break;
406 
407 		ret = regmap_set_bits(regmap, info->modeset_reg, info->modeset_mask);
408 
409 		mt6363_buck_unlock(regmap, false);
410 		break;
411 	case REGULATOR_MODE_NORMAL:
412 		cur_mode = mt6363_regulator_get_mode(rdev);
413 		if (cur_mode < 0) {
414 			ret = cur_mode;
415 			break;
416 		}
417 
418 		if (cur_mode == REGULATOR_MODE_FAST) {
419 			ret = mt6363_buck_unlock(regmap, true);
420 			if (ret)
421 				break;
422 
423 			ret = regmap_clear_bits(regmap, info->modeset_reg, info->modeset_mask);
424 
425 			mt6363_buck_unlock(regmap, false);
426 			break;
427 		} else if (cur_mode == REGULATOR_MODE_IDLE) {
428 			ret = regmap_clear_bits(regmap, info->lp_mode_reg, info->lp_mode_mask);
429 			if (ret == 0)
430 				usleep_range(100, 200);
431 		} else {
432 			ret = 0;
433 		}
434 		break;
435 	case REGULATOR_MODE_IDLE:
436 		ret = regmap_set_bits(regmap, info->lp_mode_reg, info->lp_mode_mask);
437 		break;
438 	default:
439 		ret = -EINVAL;
440 	}
441 
442 	if (ret) {
443 		dev_err(&rdev->dev, "Failed to set mode %u: %d\n", mode, ret);
444 		return ret;
445 	}
446 
447 	return 0;
448 }
449 
450 static int mt6363_regulator_set_load(struct regulator_dev *rdev, int load_uA)
451 {
452 	struct mt6363_regulator_info *info = rdev_get_drvdata(rdev);
453 	unsigned int opmode_cfg, opmode_en;
454 	int i, ret;
455 
456 	if (!info->lp_imax_uA)
457 		return -EINVAL;
458 
459 	if (load_uA >= info->lp_imax_uA) {
460 		ret = mt6363_regulator_set_mode(rdev, REGULATOR_MODE_NORMAL);
461 		if (ret)
462 			return ret;
463 
464 		opmode_cfg = NORMAL_OP_CFG;
465 		opmode_en = NORMAL_OP_EN;
466 	} else {
467 		opmode_cfg = info->orig_op_cfg;
468 		opmode_en = info->orig_op_en;
469 	}
470 
471 	ret = regmap_write(rdev->regmap, info->op_en_reg + OP_CFG_OFFSET, opmode_cfg);
472 	if (ret)
473 		return ret;
474 
475 	for (i = 0; i < 3; i++) {
476 		ret = regmap_write(rdev->regmap, info->op_en_reg + i,
477 				   (opmode_en >> (i * 8)) & GENMASK(7, 0));
478 		if (ret)
479 			return ret;
480 	}
481 
482 	return 0;
483 }
484 
485 static int mt6363_vemc_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
486 {
487 	const __le16 tma_unlock_key = cpu_to_le16(MT6363_TMA_UNLOCK_VALUE);
488 	const __le16 tma_lock_key = cpu_to_le16(0);
489 	int ret;
490 
491 	/* Unlock TMA for writing */
492 	ret = regmap_bulk_write(rdev->regmap, MT6363_TOP_TMA_KEY_L,
493 				&tma_unlock_key, sizeof(tma_unlock_key));
494 	if (ret)
495 		return ret;
496 
497 	ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
498 
499 	/* Unconditionally re-lock TMA */
500 	regmap_bulk_write(rdev->regmap, MT6363_TOP_TMA_KEY_L,
501 			  &tma_lock_key, sizeof(tma_lock_key));
502 
503 	return ret;
504 }
505 
506 static int mt6363_va15_set_voltage_sel(struct regulator_dev *rdev, unsigned int sel)
507 {
508 	struct regmap *regmap = rdev->regmap;
509 	int ret;
510 
511 	ret = mt6363_buck_unlock(regmap, true);
512 	if (ret)
513 		return ret;
514 
515 	ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
516 	if (ret)
517 		goto va15_unlock;
518 
519 	ret = regmap_update_bits(regmap, MT6363_RG_BUCK_EFUSE_RSV1,
520 				 MT6363_RG_BUCK_EFUSE_RSV1_MASK, sel);
521 	if (ret)
522 		goto va15_unlock;
523 
524 va15_unlock:
525 	mt6363_buck_unlock(rdev->regmap, false);
526 	return ret;
527 }
528 
529 static void mt6363_oc_irq_enable_work(struct work_struct *work)
530 {
531 	struct delayed_work *dwork = to_delayed_work(work);
532 	struct mt6363_regulator_info *info =
533 		container_of(dwork, struct mt6363_regulator_info, oc_work);
534 
535 	enable_irq(info->virq);
536 }
537 
538 static irqreturn_t mt6363_oc_isr(int irq, void *data)
539 {
540 	struct regulator_dev *rdev = (struct regulator_dev *)data;
541 	struct mt6363_regulator_info *info = rdev_get_drvdata(rdev);
542 
543 	disable_irq_nosync(info->virq);
544 
545 	if (regulator_is_enabled_regmap(rdev))
546 		regulator_notifier_call_chain(rdev, REGULATOR_EVENT_OVER_CURRENT, NULL);
547 
548 	schedule_delayed_work(&info->oc_work, msecs_to_jiffies(OC_IRQ_ENABLE_DELAY_MS));
549 
550 	return IRQ_HANDLED;
551 }
552 
553 static int mt6363_set_ocp(struct regulator_dev *rdev, int lim, int severity, bool enable)
554 {
555 	struct mt6363_regulator_info *info = rdev_get_drvdata(rdev);
556 
557 	/* MT6363 supports only enabling protection and does not support limits */
558 	if (lim || severity != REGULATOR_SEVERITY_PROT || !enable)
559 		return -EOPNOTSUPP;
560 
561 	/* If there is no OCP interrupt, there's nothing to set */
562 	if (info->virq <= 0)
563 		return -EOPNOTSUPP;
564 
565 	return devm_request_threaded_irq(&rdev->dev, info->virq, NULL,
566 					 mt6363_oc_isr, IRQF_ONESHOT,
567 					 info->desc.name, rdev);
568 }
569 
570 static const struct regulator_ops mt6363_vreg_setclr_ops = {
571 	.list_voltage = regulator_list_voltage_linear,
572 	.map_voltage = regulator_map_voltage_linear,
573 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
574 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
575 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
576 	.enable = mt6363_vreg_enable_setclr,
577 	.disable = mt6363_vreg_disable_setclr,
578 	.is_enabled = regulator_is_enabled_regmap,
579 	.set_mode = mt6363_regulator_set_mode,
580 	.get_mode = mt6363_regulator_get_mode,
581 	.set_load = mt6363_regulator_set_load,
582 	.set_over_current_protection = mt6363_set_ocp,
583 };
584 
585 static const struct regulator_ops mt6363_ldo_linear_ops = {
586 	.list_voltage = regulator_list_voltage_linear,
587 	.map_voltage = regulator_map_voltage_linear,
588 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
589 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
590 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
591 	.enable = regulator_enable_regmap,
592 	.disable = regulator_disable_regmap,
593 	.is_enabled = regulator_is_enabled_regmap,
594 	.set_mode = mt6363_regulator_set_mode,
595 	.get_mode = mt6363_regulator_get_mode,
596 	.set_over_current_protection = mt6363_set_ocp,
597 };
598 
599 static const struct regulator_ops mt6363_ldo_vtable_ops = {
600 	.list_voltage = regulator_list_voltage_pickable_linear_range,
601 	.map_voltage = regulator_map_voltage_pickable_linear_range,
602 	.set_voltage_sel = regulator_set_voltage_sel_pickable_regmap,
603 	.get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
604 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
605 	.enable = regulator_enable_regmap,
606 	.disable = regulator_disable_regmap,
607 	.is_enabled = regulator_is_enabled_regmap,
608 	.set_mode = mt6363_regulator_set_mode,
609 	.get_mode = mt6363_regulator_get_mode,
610 	.set_load = mt6363_regulator_set_load,
611 	.set_over_current_protection = mt6363_set_ocp,
612 };
613 
614 static const struct regulator_ops mt6363_ldo_vemc_ops = {
615 	.list_voltage = regulator_list_voltage_pickable_linear_range,
616 	.map_voltage = regulator_map_voltage_pickable_linear_range,
617 	.set_voltage_sel = mt6363_vemc_set_voltage_sel,
618 	.get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
619 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
620 	.enable = regulator_enable_regmap,
621 	.disable = regulator_disable_regmap,
622 	.is_enabled = regulator_is_enabled_regmap,
623 	.set_mode = mt6363_regulator_set_mode,
624 	.get_mode = mt6363_regulator_get_mode,
625 	.set_load = mt6363_regulator_set_load,
626 	.set_over_current_protection = mt6363_set_ocp,
627 };
628 
629 static const struct regulator_ops mt6363_ldo_va15_ops = {
630 	.list_voltage = regulator_list_voltage_pickable_linear_range,
631 	.map_voltage = regulator_map_voltage_pickable_linear_range,
632 	.set_voltage_sel = mt6363_va15_set_voltage_sel,
633 	.get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
634 	.set_voltage_time_sel = regulator_set_voltage_time_sel,
635 	.enable = regulator_enable_regmap,
636 	.disable = regulator_disable_regmap,
637 	.is_enabled = regulator_is_enabled_regmap,
638 	.set_mode = mt6363_regulator_set_mode,
639 	.get_mode = mt6363_regulator_get_mode,
640 	.set_load = mt6363_regulator_set_load,
641 	.set_over_current_protection = mt6363_set_ocp,
642 };
643 
644 /* The array is indexed by id(MT6363_ID_XXX) */
645 static struct mt6363_regulator_info mt6363_regulators[] = {
646 	MT6363_BUCK("vbuck1", VBUCK1, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
647 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 1),
648 	MT6363_BUCK("vbuck2", VBUCK2, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
649 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 2),
650 	MT6363_BUCK("vbuck3", VBUCK3, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
651 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 3),
652 	MT6363_BUCK("vbuck4", VBUCK4, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
653 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 4),
654 	MT6363_BUCK("vbuck5", VBUCK5, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
655 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 5),
656 	MT6363_BUCK("vbuck6", VBUCK6, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
657 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 6),
658 	MT6363_BUCK("vbuck7", VBUCK7, 0, 1193750, 6250, MT6363_RG_BUCK0_EN_ADDR,
659 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_1_FCCM_ADDR, 7),
660 	MT6363_BUCK("vs1", VS1, 0, 2200000, 12500, MT6363_RG_BUCK1_EN_ADDR,
661 		    MT6363_RG_BUCK1_LP_ADDR, MT6363_RG_VS1_FCCM_ADDR, 8),
662 	MT6363_BUCK("vs2", VS2, 0, 1600000, 12500, MT6363_RG_BUCK0_EN_ADDR,
663 		    MT6363_RG_BUCK0_LP_ADDR, MT6363_RG_BUCK0_FCCM_ADDR, 0),
664 	MT6363_BUCK("vs3", VS3, 0, 1193750, 6250, MT6363_RG_BUCK1_EN_ADDR,
665 		    MT6363_RG_BUCK1_LP_ADDR, MT6363_RG_VS3_FCCM_ADDR, 9),
666 	MT6363_LDO_VT("va12-1", VA12_1, "vs2-ldo2", 3, 37),
667 	MT6363_LDO_VT("va12-2", VA12_2, "vs2-ldo2", 3, 38),
668 	MT6363_LDO_LINEAR_CAL_OPS("va15", VA15, "vs1-ldo1", mt6363_ldo_va15_ops, 3, 39),
669 	MT6363_LDO_VT("vaux18", VAUX18, "vsys-ldo1", 2, 31),
670 	MT6363_LDO_VT("vcn13", VCN13, "vs2-ldo2", 1, 17),
671 	MT6363_LDO_VT("vcn15", VCN15, "vs1-ldo2", 3, 16),
672 	MT6363_LDO_LINEAR_CAL_OPS("vemc", VEMC, "vsys-ldo1", mt6363_ldo_vemc_ops, 0, 32),
673 	MT6363_LDO_VT("vio0p75", VIO075, "vs1-ldo1", 5, 36),
674 	MT6363_LDO_VT("vio18", VIO18, "vs1-ldo2", 3, 35),
675 	MT6363_LDO_VT("vm18", VM18, "vs1-ldo1", 4, 40),
676 	MT6363_LDO_L("vsram-apu", VSRAM_APU, "vs3-ldo1", 400000, 1193750, 6250, 30),
677 	MT6363_LDO_L("vsram-cpub", VSRAM_CPUB, "vs2-ldo1", 400000, 1193750, 6250, 27),
678 	MT6363_LDO_L("vsram-cpum", VSRAM_CPUM, "vs2-ldo1", 400000, 1193750, 6250, 28),
679 	MT6363_LDO_L("vsram-cpul", VSRAM_CPUL, "vs2-ldo2", 400000, 1193750, 6250, 29),
680 	MT6363_LDO_L_SC("vsram-digrf", VSRAM_DIGRF, "vs3-ldo1", 400000, 1193750, 6250, BUCK1, 23),
681 	MT6363_LDO_L_SC("vsram-mdfe", VSRAM_MDFE, "vs3-ldo1", 400000, 1193750, 6250, BUCK1, 24),
682 	MT6363_LDO_L_SC("vsram-modem", VSRAM_MODEM, "vs3-ldo2", 400000, 1193750, 6250, BUCK1, 25),
683 	MT6363_LDO_VT("vrf0p9", VRF09, "vs3-ldo2", 1, 18),
684 	MT6363_LDO_VT("vrf12", VRF12, "vs2-ldo1", 3, 19),
685 	MT6363_LDO_VT("vrf13", VRF13, "vs2-ldo1", 1, 20),
686 	MT6363_LDO_VT("vrf18", VRF18, "vs1-ldo1", 3, 21),
687 	MT6363_LDO_VT("vrf-io18", VRFIO18, "vs1-ldo1", 3, 22),
688 	MT6363_LDO_VT("vtref18", VTREF18, "vsys-ldo1", 2, 26),
689 	MT6363_LDO_VT("vufs12", VUFS12, "vs2-ldo1", 4, 33),
690 	MT6363_LDO_VT("vufs18", VUFS18, "vs1-ldo2", 3, 34),
691 };
692 
693 static int mt6363_backup_op_setting(struct regmap *map, struct mt6363_regulator_info *info)
694 {
695 	unsigned int i, val;
696 	int ret;
697 
698 	ret = regmap_read(map, info->op_en_reg + OP_CFG_OFFSET, &val);
699 	if (ret)
700 		return ret;
701 
702 	info->orig_op_cfg = val;
703 
704 	for (i = 0; i < 3; i++) {
705 		ret = regmap_read(map, info->op_en_reg + i, &val);
706 		if (ret)
707 			return ret;
708 
709 		info->orig_op_en |= val << (i * 8);
710 	}
711 
712 	return 0;
713 }
714 
715 static int mt6363_vemc_select_bank(struct regmap *map, struct regulator_desc *desc)
716 {
717 	unsigned int trap;
718 	int ret;
719 
720 	ret = regmap_read(map, MT6363_TOP_TRAP, &trap);
721 	if (ret)
722 		return ret;
723 
724 	/* The hardware trap value selects which VEMC voltage controls are used */
725 	switch (trap) {
726 	case 0:
727 		desc->vsel_reg = MT6363_RG_VEMC_VOCAL_ADDR;
728 		desc->vsel_range_mask = MT6363_RG_VEMC_VOSEL_MASK;
729 		return 0;
730 	case 1:
731 		desc->vsel_reg = MT6363_RG_VEMC_VOCAL_1_ADDR;
732 		desc->vsel_range_mask = MT6363_RG_VEMC_VOSEL_1_MASK;
733 		return 0;
734 	default:
735 		return -EINVAL;
736 	}
737 }
738 
739 static void mt6363_irq_remove(void *data)
740 {
741 	int *virq = data;
742 
743 	irq_dispose_mapping(*virq);
744 }
745 
746 static void mt6363_spmi_remove(void *data)
747 {
748 	struct spmi_device *sdev = data;
749 
750 	spmi_device_remove(sdev);
751 };
752 
753 static struct regmap *mt6363_spmi_register_regmap(struct device *dev)
754 {
755 	struct regmap_config mt6363_regmap_config = {
756 		.reg_bits = 16,
757 		.val_bits = 8,
758 		.max_register = 0x1f90,
759 		.fast_io = true,
760 	};
761 	struct spmi_device *sdev, *sparent;
762 	u32 base;
763 	int ret;
764 
765 	if (!dev->parent)
766 		return ERR_PTR(-ENODEV);
767 
768 	ret = device_property_read_u32(dev, "reg", &base);
769 	if (ret)
770 		return ERR_PTR(ret);
771 
772 	sparent = to_spmi_device(dev->parent);
773 	if (!sparent)
774 		return ERR_PTR(-ENODEV);
775 
776 	sdev = spmi_device_alloc(sparent->ctrl);
777 	if (!sdev)
778 		return ERR_PTR(-ENODEV);
779 
780 	sdev->usid = sparent->usid;
781 	dev_set_name(&sdev->dev, "%d-%02x-regulator", sdev->ctrl->nr, sdev->usid);
782 	ret = device_add(&sdev->dev);
783 	if (ret) {
784 		put_device(&sdev->dev);
785 		return ERR_PTR(ret);
786 	};
787 
788 	ret = devm_add_action_or_reset(dev, mt6363_spmi_remove, sdev);
789 	if (ret)
790 		return ERR_PTR(ret);
791 
792 	mt6363_regmap_config.reg_base = base;
793 
794 	return devm_regmap_init_spmi_ext(sdev, &mt6363_regmap_config);
795 }
796 
797 static int mt6363_regulator_probe(struct platform_device *pdev)
798 {
799 	struct device_node *interrupt_parent;
800 	struct regulator_config config = {};
801 	struct mt6363_regulator_info *info;
802 	struct device *dev = &pdev->dev;
803 	struct regulator_dev *rdev;
804 	struct irq_domain *domain;
805 	struct irq_fwspec fwspec;
806 	struct spmi_device *sdev;
807 	int i, ret, val;
808 
809 	config.regmap = mt6363_spmi_register_regmap(dev);
810 	if (IS_ERR(config.regmap))
811 		return dev_err_probe(dev, PTR_ERR(config.regmap),
812 				     "Cannot get regmap\n");
813 	config.dev = dev;
814 	sdev = to_spmi_device(dev->parent);
815 
816 	/*
817 	 * The first read may fail if the bootloader sets sleep mode: wake up
818 	 * this PMIC with W/R on the SPMI bus and ignore the first result.
819 	 * This matches the MT6373 driver behavior.
820 	 */
821 	regmap_read(config.regmap, MT6363_TOP_TRAP, &val);
822 
823 	ret = mt6363_vemc_select_bank(config.regmap,
824 				      &mt6363_regulators[MT6363_ID_VEMC].desc);
825 	if (ret)
826 		return dev_err_probe(dev, ret, "Failed to select VEMC bank\n");
827 
828 	interrupt_parent = of_irq_find_parent(dev->of_node);
829 	if (!interrupt_parent)
830 		return dev_err_probe(dev, -EINVAL, "Cannot find IRQ parent\n");
831 
832 	domain = irq_find_host(interrupt_parent);
833 	of_node_put(interrupt_parent);
834 	fwspec.fwnode = domain->fwnode;
835 
836 	fwspec.param_count = 3;
837 	fwspec.param[0] = sdev->usid;
838 	fwspec.param[2] = IRQ_TYPE_LEVEL_HIGH;
839 
840 	for (i = 0; i < ARRAY_SIZE(mt6363_regulators); i++) {
841 		info = &mt6363_regulators[i];
842 
843 		fwspec.param[1] = info->hwirq;
844 		info->virq = irq_create_fwspec_mapping(&fwspec);
845 		if (!info->virq)
846 			return dev_err_probe(dev, -EINVAL,
847 					     "Failed to map IRQ%d\n", info->hwirq);
848 
849 		ret = devm_add_action_or_reset(dev, mt6363_irq_remove, &info->virq);
850 		if (ret)
851 			return ret;
852 
853 		config.driver_data = info;
854 		INIT_DELAYED_WORK(&info->oc_work, mt6363_oc_irq_enable_work);
855 
856 		rdev = devm_regulator_register(dev, &info->desc, &config);
857 		if (IS_ERR(rdev))
858 			return dev_err_probe(dev, PTR_ERR(rdev),
859 					     "failed to register %s\n", info->desc.name);
860 
861 		if (info->lp_imax_uA) {
862 			ret = mt6363_backup_op_setting(config.regmap, info);
863 			if (ret) {
864 				dev_warn(dev, "Failed to backup op_setting for %s\n",
865 					 info->desc.name);
866 				info->lp_imax_uA = 0;
867 			}
868 		}
869 	}
870 
871 	return 0;
872 }
873 
874 static const struct of_device_id mt6363_regulator_match[] = {
875 	{ .compatible = "mediatek,mt6363-regulator" },
876 	{ /* sentinel */ }
877 };
878 MODULE_DEVICE_TABLE(of, mt6363_regulator_match);
879 
880 static struct platform_driver mt6363_regulator_driver = {
881 	.driver = {
882 		.name = "mt6363-regulator",
883 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
884 		.of_match_table = mt6363_regulator_match,
885 	},
886 	.probe = mt6363_regulator_probe,
887 };
888 module_platform_driver(mt6363_regulator_driver);
889 
890 MODULE_AUTHOR("AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>");
891 MODULE_DESCRIPTION("Regulator Driver for MediaTek MT6363 PMIC");
892 MODULE_LICENSE("GPL");
893