1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) STMicroelectronics 2018
3 // Author: Pascal Paillet <p.paillet@st.com> for STMicroelectronics.
4 
5 #include <linux/interrupt.h>
6 #include <linux/mfd/stpmic1.h>
7 #include <linux/module.h>
8 #include <linux/of_irq.h>
9 #include <linux/platform_device.h>
10 #include <linux/regmap.h>
11 #include <linux/regulator/driver.h>
12 #include <linux/regulator/machine.h>
13 #include <linux/regulator/of_regulator.h>
14 
15 #include <dt-bindings/mfd/st,stpmic1.h>
16 
17 /**
18  * struct stpmic1 regulator description: this structure is used as driver data
19  * @desc: regulator framework description
20  * @mask_reset_reg: mask reset register address
21  * @mask_reset_mask: mask rank and mask reset register mask
22  * @icc_reg: icc register address
23  * @icc_mask: icc register mask
24  */
25 struct stpmic1_regulator_cfg {
26 	struct regulator_desc desc;
27 	u8 mask_reset_reg;
28 	u8 mask_reset_mask;
29 	u8 icc_reg;
30 	u8 icc_mask;
31 };
32 
33 static int stpmic1_set_mode(struct regulator_dev *rdev, unsigned int mode);
34 static unsigned int stpmic1_get_mode(struct regulator_dev *rdev);
35 static int stpmic1_set_icc(struct regulator_dev *rdev, int lim, int severity,
36 			   bool enable);
37 static unsigned int stpmic1_map_mode(unsigned int mode);
38 
39 enum {
40 	STPMIC1_BUCK1 = 0,
41 	STPMIC1_BUCK2 = 1,
42 	STPMIC1_BUCK3 = 2,
43 	STPMIC1_BUCK4 = 3,
44 	STPMIC1_LDO1 = 4,
45 	STPMIC1_LDO2 = 5,
46 	STPMIC1_LDO3 = 6,
47 	STPMIC1_LDO4 = 7,
48 	STPMIC1_LDO5 = 8,
49 	STPMIC1_LDO6 = 9,
50 	STPMIC1_VREF_DDR = 10,
51 	STPMIC1_BOOST = 11,
52 	STPMIC1_VBUS_OTG = 12,
53 	STPMIC1_SW_OUT = 13,
54 };
55 
56 /* Enable time worst case is 5000mV/(2250uV/uS) */
57 #define PMIC_ENABLE_TIME_US 2200
58 /* Ramp delay worst case is (2250uV/uS) */
59 #define PMIC_RAMP_DELAY 2200
60 
61 static const struct linear_range buck1_ranges[] = {
62 	REGULATOR_LINEAR_RANGE(725000, 0, 4, 0),
63 	REGULATOR_LINEAR_RANGE(725000, 5, 36, 25000),
64 	REGULATOR_LINEAR_RANGE(1500000, 37, 63, 0),
65 };
66 
67 static const struct linear_range buck2_ranges[] = {
68 	REGULATOR_LINEAR_RANGE(1000000, 0, 17, 0),
69 	REGULATOR_LINEAR_RANGE(1050000, 18, 19, 0),
70 	REGULATOR_LINEAR_RANGE(1100000, 20, 21, 0),
71 	REGULATOR_LINEAR_RANGE(1150000, 22, 23, 0),
72 	REGULATOR_LINEAR_RANGE(1200000, 24, 25, 0),
73 	REGULATOR_LINEAR_RANGE(1250000, 26, 27, 0),
74 	REGULATOR_LINEAR_RANGE(1300000, 28, 29, 0),
75 	REGULATOR_LINEAR_RANGE(1350000, 30, 31, 0),
76 	REGULATOR_LINEAR_RANGE(1400000, 32, 33, 0),
77 	REGULATOR_LINEAR_RANGE(1450000, 34, 35, 0),
78 	REGULATOR_LINEAR_RANGE(1500000, 36, 63, 0),
79 };
80 
81 static const struct linear_range buck3_ranges[] = {
82 	REGULATOR_LINEAR_RANGE(1000000, 0, 19, 0),
83 	REGULATOR_LINEAR_RANGE(1100000, 20, 23, 0),
84 	REGULATOR_LINEAR_RANGE(1200000, 24, 27, 0),
85 	REGULATOR_LINEAR_RANGE(1300000, 28, 31, 0),
86 	REGULATOR_LINEAR_RANGE(1400000, 32, 35, 0),
87 	REGULATOR_LINEAR_RANGE(1500000, 36, 55, 100000),
88 	REGULATOR_LINEAR_RANGE(3400000, 56, 63, 0),
89 };
90 
91 static const struct linear_range buck4_ranges[] = {
92 	REGULATOR_LINEAR_RANGE(600000, 0, 27, 25000),
93 	REGULATOR_LINEAR_RANGE(1300000, 28, 29, 0),
94 	REGULATOR_LINEAR_RANGE(1350000, 30, 31, 0),
95 	REGULATOR_LINEAR_RANGE(1400000, 32, 33, 0),
96 	REGULATOR_LINEAR_RANGE(1450000, 34, 35, 0),
97 	REGULATOR_LINEAR_RANGE(1500000, 36, 60, 100000),
98 	REGULATOR_LINEAR_RANGE(3900000, 61, 63, 0),
99 };
100 
101 static const struct linear_range ldo1_ranges[] = {
102 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
103 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
104 	REGULATOR_LINEAR_RANGE(3300000, 25, 31, 0),
105 };
106 
107 static const struct linear_range ldo2_ranges[] = {
108 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
109 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
110 	REGULATOR_LINEAR_RANGE(3300000, 25, 30, 0),
111 };
112 
113 static const struct linear_range ldo3_ranges[] = {
114 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
115 	REGULATOR_LINEAR_RANGE(1700000, 8, 24, 100000),
116 	REGULATOR_LINEAR_RANGE(3300000, 25, 30, 0),
117 	/* with index 31 LDO3 is in DDR mode */
118 	REGULATOR_LINEAR_RANGE(500000, 31, 31, 0),
119 };
120 
121 static const struct linear_range ldo5_ranges[] = {
122 	REGULATOR_LINEAR_RANGE(1700000, 0, 7, 0),
123 	REGULATOR_LINEAR_RANGE(1700000, 8, 30, 100000),
124 	REGULATOR_LINEAR_RANGE(3900000, 31, 31, 0),
125 };
126 
127 static const struct linear_range ldo6_ranges[] = {
128 	REGULATOR_LINEAR_RANGE(900000, 0, 24, 100000),
129 	REGULATOR_LINEAR_RANGE(3300000, 25, 31, 0),
130 };
131 
132 static const struct regulator_ops stpmic1_ldo_ops = {
133 	.list_voltage = regulator_list_voltage_linear_range,
134 	.map_voltage = regulator_map_voltage_linear_range,
135 	.is_enabled = regulator_is_enabled_regmap,
136 	.enable = regulator_enable_regmap,
137 	.disable = regulator_disable_regmap,
138 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
139 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
140 	.set_over_current_protection = stpmic1_set_icc,
141 };
142 
143 static const struct regulator_ops stpmic1_ldo3_ops = {
144 	.list_voltage = regulator_list_voltage_linear_range,
145 	.map_voltage = regulator_map_voltage_iterate,
146 	.is_enabled = regulator_is_enabled_regmap,
147 	.enable = regulator_enable_regmap,
148 	.disable = regulator_disable_regmap,
149 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
150 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
151 	.get_bypass = regulator_get_bypass_regmap,
152 	.set_bypass = regulator_set_bypass_regmap,
153 	.set_over_current_protection = stpmic1_set_icc,
154 };
155 
156 static const struct regulator_ops stpmic1_ldo4_fixed_regul_ops = {
157 	.is_enabled = regulator_is_enabled_regmap,
158 	.enable = regulator_enable_regmap,
159 	.disable = regulator_disable_regmap,
160 	.set_over_current_protection = stpmic1_set_icc,
161 };
162 
163 static const struct regulator_ops stpmic1_buck_ops = {
164 	.list_voltage = regulator_list_voltage_linear_range,
165 	.map_voltage = regulator_map_voltage_linear_range,
166 	.is_enabled = regulator_is_enabled_regmap,
167 	.enable = regulator_enable_regmap,
168 	.disable = regulator_disable_regmap,
169 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
170 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
171 	.set_pull_down = regulator_set_pull_down_regmap,
172 	.set_mode = stpmic1_set_mode,
173 	.get_mode = stpmic1_get_mode,
174 	.set_over_current_protection = stpmic1_set_icc,
175 };
176 
177 static const struct regulator_ops stpmic1_vref_ddr_ops = {
178 	.is_enabled = regulator_is_enabled_regmap,
179 	.enable = regulator_enable_regmap,
180 	.disable = regulator_disable_regmap,
181 };
182 
183 static const struct regulator_ops stpmic1_boost_regul_ops = {
184 	.is_enabled = regulator_is_enabled_regmap,
185 	.enable = regulator_enable_regmap,
186 	.disable = regulator_disable_regmap,
187 	.set_over_current_protection = stpmic1_set_icc,
188 };
189 
190 static const struct regulator_ops stpmic1_switch_regul_ops = {
191 	.is_enabled = regulator_is_enabled_regmap,
192 	.enable = regulator_enable_regmap,
193 	.disable = regulator_disable_regmap,
194 	.set_over_current_protection = stpmic1_set_icc,
195 	.set_active_discharge = regulator_set_active_discharge_regmap,
196 };
197 
198 #define REG_LDO(ids, base) { \
199 	.name = #ids, \
200 	.id = STPMIC1_##ids, \
201 	.n_voltages = 32, \
202 	.ops = &stpmic1_ldo_ops, \
203 	.linear_ranges = base ## _ranges, \
204 	.n_linear_ranges = ARRAY_SIZE(base ## _ranges), \
205 	.type = REGULATOR_VOLTAGE, \
206 	.owner = THIS_MODULE, \
207 	.vsel_reg = ids##_ACTIVE_CR, \
208 	.vsel_mask = LDO_VOLTAGE_MASK, \
209 	.enable_reg = ids##_ACTIVE_CR, \
210 	.enable_mask = LDO_ENABLE_MASK, \
211 	.enable_val = 1, \
212 	.disable_val = 0, \
213 	.enable_time = PMIC_ENABLE_TIME_US, \
214 	.ramp_delay = PMIC_RAMP_DELAY, \
215 	.supply_name = #base, \
216 }
217 
218 #define REG_LDO3(ids, base) { \
219 	.name = #ids, \
220 	.id = STPMIC1_##ids, \
221 	.n_voltages = 32, \
222 	.ops = &stpmic1_ldo3_ops, \
223 	.linear_ranges = ldo3_ranges, \
224 	.n_linear_ranges = ARRAY_SIZE(ldo3_ranges), \
225 	.type = REGULATOR_VOLTAGE, \
226 	.owner = THIS_MODULE, \
227 	.vsel_reg = LDO3_ACTIVE_CR, \
228 	.vsel_mask = LDO_VOLTAGE_MASK, \
229 	.enable_reg = LDO3_ACTIVE_CR, \
230 	.enable_mask = LDO_ENABLE_MASK, \
231 	.enable_val = 1, \
232 	.disable_val = 0, \
233 	.enable_time = PMIC_ENABLE_TIME_US, \
234 	.ramp_delay = PMIC_RAMP_DELAY, \
235 	.bypass_reg = LDO3_ACTIVE_CR, \
236 	.bypass_mask = LDO_BYPASS_MASK, \
237 	.bypass_val_on = LDO_BYPASS_MASK, \
238 	.bypass_val_off = 0, \
239 	.supply_name = #base, \
240 }
241 
242 #define REG_LDO4(ids, base) { \
243 	.name = #ids, \
244 	.id = STPMIC1_##ids, \
245 	.n_voltages = 1, \
246 	.ops = &stpmic1_ldo4_fixed_regul_ops, \
247 	.type = REGULATOR_VOLTAGE, \
248 	.owner = THIS_MODULE, \
249 	.min_uV = 3300000, \
250 	.fixed_uV = 3300000, \
251 	.enable_reg = LDO4_ACTIVE_CR, \
252 	.enable_mask = LDO_ENABLE_MASK, \
253 	.enable_val = 1, \
254 	.disable_val = 0, \
255 	.enable_time = PMIC_ENABLE_TIME_US, \
256 	.ramp_delay = PMIC_RAMP_DELAY, \
257 	.supply_name = #base, \
258 }
259 
260 #define REG_BUCK(ids, base) { \
261 	.name = #ids, \
262 	.id = STPMIC1_##ids, \
263 	.ops = &stpmic1_buck_ops, \
264 	.n_voltages = 64, \
265 	.linear_ranges = base ## _ranges, \
266 	.n_linear_ranges = ARRAY_SIZE(base ## _ranges), \
267 	.type = REGULATOR_VOLTAGE, \
268 	.owner = THIS_MODULE, \
269 	.vsel_reg = ids##_ACTIVE_CR, \
270 	.vsel_mask = BUCK_VOLTAGE_MASK, \
271 	.enable_reg = ids##_ACTIVE_CR, \
272 	.enable_mask = BUCK_ENABLE_MASK, \
273 	.enable_val = 1, \
274 	.disable_val = 0, \
275 	.enable_time = PMIC_ENABLE_TIME_US, \
276 	.ramp_delay = PMIC_RAMP_DELAY, \
277 	.of_map_mode = stpmic1_map_mode, \
278 	.pull_down_reg = ids##_PULL_DOWN_REG, \
279 	.pull_down_mask = ids##_PULL_DOWN_MASK, \
280 	.supply_name = #base, \
281 }
282 
283 #define REG_VREF_DDR(ids, base) { \
284 	.name = #ids, \
285 	.id = STPMIC1_##ids, \
286 	.n_voltages = 1, \
287 	.ops = &stpmic1_vref_ddr_ops, \
288 	.type = REGULATOR_VOLTAGE, \
289 	.owner = THIS_MODULE, \
290 	.min_uV = 500000, \
291 	.fixed_uV = 500000, \
292 	.enable_reg = VREF_DDR_ACTIVE_CR, \
293 	.enable_mask = BUCK_ENABLE_MASK, \
294 	.enable_val = 1, \
295 	.disable_val = 0, \
296 	.enable_time = PMIC_ENABLE_TIME_US, \
297 	.supply_name = #base, \
298 }
299 
300 #define REG_BOOST(ids, base) { \
301 	.name = #ids, \
302 	.id = STPMIC1_##ids, \
303 	.n_voltages = 1, \
304 	.ops = &stpmic1_boost_regul_ops, \
305 	.type = REGULATOR_VOLTAGE, \
306 	.owner = THIS_MODULE, \
307 	.min_uV = 0, \
308 	.fixed_uV = 5000000, \
309 	.enable_reg = BST_SW_CR, \
310 	.enable_mask = BOOST_ENABLED, \
311 	.enable_val = BOOST_ENABLED, \
312 	.disable_val = 0, \
313 	.enable_time = PMIC_ENABLE_TIME_US, \
314 	.supply_name = #base, \
315 }
316 
317 #define REG_VBUS_OTG(ids, base) { \
318 	.name = #ids, \
319 	.id = STPMIC1_##ids, \
320 	.n_voltages = 1, \
321 	.ops = &stpmic1_switch_regul_ops, \
322 	.type = REGULATOR_VOLTAGE, \
323 	.owner = THIS_MODULE, \
324 	.min_uV = 0, \
325 	.fixed_uV = 5000000, \
326 	.enable_reg = BST_SW_CR, \
327 	.enable_mask = USBSW_OTG_SWITCH_ENABLED, \
328 	.enable_val = USBSW_OTG_SWITCH_ENABLED, \
329 	.disable_val = 0, \
330 	.enable_time = PMIC_ENABLE_TIME_US, \
331 	.supply_name = #base, \
332 	.active_discharge_reg = BST_SW_CR, \
333 	.active_discharge_mask = VBUS_OTG_DISCHARGE, \
334 	.active_discharge_on = VBUS_OTG_DISCHARGE, \
335 }
336 
337 #define REG_SW_OUT(ids, base) { \
338 	.name = #ids, \
339 	.id = STPMIC1_##ids, \
340 	.n_voltages = 1, \
341 	.ops = &stpmic1_switch_regul_ops, \
342 	.type = REGULATOR_VOLTAGE, \
343 	.owner = THIS_MODULE, \
344 	.min_uV = 0, \
345 	.fixed_uV = 5000000, \
346 	.enable_reg = BST_SW_CR, \
347 	.enable_mask = SWIN_SWOUT_ENABLED, \
348 	.enable_val = SWIN_SWOUT_ENABLED, \
349 	.disable_val = 0, \
350 	.enable_time = PMIC_ENABLE_TIME_US, \
351 	.supply_name = #base, \
352 	.active_discharge_reg = BST_SW_CR, \
353 	.active_discharge_mask = SW_OUT_DISCHARGE, \
354 	.active_discharge_on = SW_OUT_DISCHARGE, \
355 }
356 
357 static const struct stpmic1_regulator_cfg stpmic1_regulator_cfgs[] = {
358 	[STPMIC1_BUCK1] = {
359 		.desc = REG_BUCK(BUCK1, buck1),
360 		.icc_reg = BUCKS_ICCTO_CR,
361 		.icc_mask = BIT(0),
362 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
363 		.mask_reset_mask = BIT(0),
364 	},
365 	[STPMIC1_BUCK2] = {
366 		.desc = REG_BUCK(BUCK2, buck2),
367 		.icc_reg = BUCKS_ICCTO_CR,
368 		.icc_mask = BIT(1),
369 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
370 		.mask_reset_mask = BIT(1),
371 	},
372 	[STPMIC1_BUCK3] = {
373 		.desc = REG_BUCK(BUCK3, buck3),
374 		.icc_reg = BUCKS_ICCTO_CR,
375 		.icc_mask = BIT(2),
376 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
377 		.mask_reset_mask = BIT(2),
378 	},
379 	[STPMIC1_BUCK4] = {
380 		.desc = REG_BUCK(BUCK4, buck4),
381 		.icc_reg = BUCKS_ICCTO_CR,
382 		.icc_mask = BIT(3),
383 		.mask_reset_reg = BUCKS_MASK_RESET_CR,
384 		.mask_reset_mask = BIT(3),
385 	},
386 	[STPMIC1_LDO1] = {
387 		.desc = REG_LDO(LDO1, ldo1),
388 		.icc_reg = LDOS_ICCTO_CR,
389 		.icc_mask = BIT(0),
390 		.mask_reset_reg = LDOS_MASK_RESET_CR,
391 		.mask_reset_mask = BIT(0),
392 	},
393 	[STPMIC1_LDO2] = {
394 		.desc = REG_LDO(LDO2, ldo2),
395 		.icc_reg = LDOS_ICCTO_CR,
396 		.icc_mask = BIT(1),
397 		.mask_reset_reg = LDOS_MASK_RESET_CR,
398 		.mask_reset_mask = BIT(1),
399 	},
400 	[STPMIC1_LDO3] = {
401 		.desc = REG_LDO3(LDO3, ldo3),
402 		.icc_reg = LDOS_ICCTO_CR,
403 		.icc_mask = BIT(2),
404 		.mask_reset_reg = LDOS_MASK_RESET_CR,
405 		.mask_reset_mask = BIT(2),
406 	},
407 	[STPMIC1_LDO4] = {
408 		.desc = REG_LDO4(LDO4, ldo4),
409 		.icc_reg = LDOS_ICCTO_CR,
410 		.icc_mask = BIT(3),
411 		.mask_reset_reg = LDOS_MASK_RESET_CR,
412 		.mask_reset_mask = BIT(3),
413 	},
414 	[STPMIC1_LDO5] = {
415 		.desc = REG_LDO(LDO5, ldo5),
416 		.icc_reg = LDOS_ICCTO_CR,
417 		.icc_mask = BIT(4),
418 		.mask_reset_reg = LDOS_MASK_RESET_CR,
419 		.mask_reset_mask = BIT(4),
420 	},
421 	[STPMIC1_LDO6] = {
422 		.desc = REG_LDO(LDO6, ldo6),
423 		.icc_reg = LDOS_ICCTO_CR,
424 		.icc_mask = BIT(5),
425 		.mask_reset_reg = LDOS_MASK_RESET_CR,
426 		.mask_reset_mask = BIT(5),
427 	},
428 	[STPMIC1_VREF_DDR] = {
429 		.desc = REG_VREF_DDR(VREF_DDR, vref_ddr),
430 		.mask_reset_reg = LDOS_MASK_RESET_CR,
431 		.mask_reset_mask = BIT(6),
432 	},
433 	[STPMIC1_BOOST] = {
434 		.desc = REG_BOOST(BOOST, boost),
435 		.icc_reg = BUCKS_ICCTO_CR,
436 		.icc_mask = BIT(6),
437 	},
438 	[STPMIC1_VBUS_OTG] = {
439 		.desc = REG_VBUS_OTG(VBUS_OTG, pwr_sw1),
440 		.icc_reg = BUCKS_ICCTO_CR,
441 		.icc_mask = BIT(4),
442 	},
443 	[STPMIC1_SW_OUT] = {
444 		.desc = REG_SW_OUT(SW_OUT, pwr_sw2),
445 		.icc_reg = BUCKS_ICCTO_CR,
446 		.icc_mask = BIT(5),
447 	},
448 };
449 
450 static unsigned int stpmic1_map_mode(unsigned int mode)
451 {
452 	switch (mode) {
453 	case STPMIC1_BUCK_MODE_NORMAL:
454 		return REGULATOR_MODE_NORMAL;
455 	case STPMIC1_BUCK_MODE_LP:
456 		return REGULATOR_MODE_STANDBY;
457 	default:
458 		return REGULATOR_MODE_INVALID;
459 	}
460 }
461 
462 static unsigned int stpmic1_get_mode(struct regulator_dev *rdev)
463 {
464 	int value;
465 	struct regmap *regmap = rdev_get_regmap(rdev);
466 
467 	regmap_read(regmap, rdev->desc->enable_reg, &value);
468 
469 	if (value & STPMIC1_BUCK_MODE_LP)
470 		return REGULATOR_MODE_STANDBY;
471 
472 	return REGULATOR_MODE_NORMAL;
473 }
474 
475 static int stpmic1_set_mode(struct regulator_dev *rdev, unsigned int mode)
476 {
477 	int value;
478 	struct regmap *regmap = rdev_get_regmap(rdev);
479 
480 	switch (mode) {
481 	case REGULATOR_MODE_NORMAL:
482 		value = STPMIC1_BUCK_MODE_NORMAL;
483 		break;
484 	case REGULATOR_MODE_STANDBY:
485 		value = STPMIC1_BUCK_MODE_LP;
486 		break;
487 	default:
488 		return -EINVAL;
489 	}
490 
491 	return regmap_update_bits(regmap, rdev->desc->enable_reg,
492 				  STPMIC1_BUCK_MODE_LP, value);
493 }
494 
495 static int stpmic1_set_icc(struct regulator_dev *rdev, int lim, int severity,
496 			   bool enable)
497 {
498 	struct stpmic1_regulator_cfg *cfg = rdev_get_drvdata(rdev);
499 	struct regmap *regmap = rdev_get_regmap(rdev);
500 
501 	/*
502 	 * The code seems like one bit in a register controls whether OCP is
503 	 * enabled. So we might be able to turn it off here is if that
504 	 * was requested. I won't support this because I don't have the HW.
505 	 * Feel free to try and implement if you have the HW and need kernel
506 	 * to disable this.
507 	 *
508 	 * Also, I don't know if limit can be configured or if we support
509 	 * error/warning instead of protect. So I just keep existing logic
510 	 * and assume no.
511 	 */
512 	if (lim || severity != REGULATOR_SEVERITY_PROT || !enable)
513 		return -EINVAL;
514 
515 	/* enable switch off in case of over current */
516 	return regmap_update_bits(regmap, cfg->icc_reg, cfg->icc_mask,
517 				  cfg->icc_mask);
518 }
519 
520 static irqreturn_t stpmic1_curlim_irq_handler(int irq, void *data)
521 {
522 	struct regulator_dev *rdev = (struct regulator_dev *)data;
523 
524 	/* Send an overcurrent notification */
525 	regulator_notifier_call_chain(rdev,
526 				      REGULATOR_EVENT_OVER_CURRENT,
527 				      NULL);
528 
529 	return IRQ_HANDLED;
530 }
531 
532 #define MATCH(_name, _id) \
533 	[STPMIC1_##_id] = { \
534 		.name = #_name, \
535 		.desc = &stpmic1_regulator_cfgs[STPMIC1_##_id].desc, \
536 	}
537 
538 static struct of_regulator_match stpmic1_matches[] = {
539 	MATCH(buck1, BUCK1),
540 	MATCH(buck2, BUCK2),
541 	MATCH(buck3, BUCK3),
542 	MATCH(buck4, BUCK4),
543 	MATCH(ldo1, LDO1),
544 	MATCH(ldo2, LDO2),
545 	MATCH(ldo3, LDO3),
546 	MATCH(ldo4, LDO4),
547 	MATCH(ldo5, LDO5),
548 	MATCH(ldo6, LDO6),
549 	MATCH(vref_ddr, VREF_DDR),
550 	MATCH(boost, BOOST),
551 	MATCH(pwr_sw1, VBUS_OTG),
552 	MATCH(pwr_sw2, SW_OUT),
553 };
554 
555 static int stpmic1_regulator_register(struct platform_device *pdev, int id,
556 				      struct of_regulator_match *match,
557 				      const struct stpmic1_regulator_cfg *cfg)
558 {
559 	struct stpmic1 *pmic_dev = dev_get_drvdata(pdev->dev.parent);
560 	struct regulator_dev *rdev;
561 	struct regulator_config config = {};
562 	int ret = 0;
563 	int irq;
564 
565 	config.dev = &pdev->dev;
566 	config.init_data = match->init_data;
567 	config.of_node = match->of_node;
568 	config.regmap = pmic_dev->regmap;
569 	config.driver_data = (void *)cfg;
570 
571 	rdev = devm_regulator_register(&pdev->dev, &cfg->desc, &config);
572 	if (IS_ERR(rdev)) {
573 		dev_err(&pdev->dev, "failed to register %s regulator\n",
574 			cfg->desc.name);
575 		return PTR_ERR(rdev);
576 	}
577 
578 	/* set mask reset */
579 	if (of_property_read_bool(config.of_node, "st,mask-reset") &&
580 	    cfg->mask_reset_reg != 0) {
581 		ret = regmap_update_bits(pmic_dev->regmap,
582 					 cfg->mask_reset_reg,
583 					 cfg->mask_reset_mask,
584 					 cfg->mask_reset_mask);
585 		if (ret) {
586 			dev_err(&pdev->dev, "set mask reset failed\n");
587 			return ret;
588 		}
589 	}
590 
591 	/* setup an irq handler for over-current detection */
592 	irq = of_irq_get(config.of_node, 0);
593 	if (irq > 0) {
594 		ret = devm_request_threaded_irq(&pdev->dev,
595 						irq, NULL,
596 						stpmic1_curlim_irq_handler,
597 						IRQF_ONESHOT | IRQF_SHARED,
598 						pdev->name, rdev);
599 		if (ret) {
600 			dev_err(&pdev->dev, "Request IRQ failed\n");
601 			return ret;
602 		}
603 	}
604 	return 0;
605 }
606 
607 static int stpmic1_regulator_probe(struct platform_device *pdev)
608 {
609 	int i, ret;
610 
611 	ret = of_regulator_match(&pdev->dev, pdev->dev.of_node, stpmic1_matches,
612 				 ARRAY_SIZE(stpmic1_matches));
613 	if (ret < 0) {
614 		dev_err(&pdev->dev,
615 			"Error in PMIC regulator device tree node");
616 		return ret;
617 	}
618 
619 	for (i = 0; i < ARRAY_SIZE(stpmic1_regulator_cfgs); i++) {
620 		ret = stpmic1_regulator_register(pdev, i, &stpmic1_matches[i],
621 						 &stpmic1_regulator_cfgs[i]);
622 		if (ret < 0)
623 			return ret;
624 	}
625 
626 	dev_dbg(&pdev->dev, "stpmic1_regulator driver probed\n");
627 
628 	return 0;
629 }
630 
631 static const struct of_device_id of_pmic_regulator_match[] = {
632 	{ .compatible = "st,stpmic1-regulators" },
633 	{ },
634 };
635 
636 MODULE_DEVICE_TABLE(of, of_pmic_regulator_match);
637 
638 static struct platform_driver stpmic1_regulator_driver = {
639 	.driver = {
640 		.name = "stpmic1-regulator",
641 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
642 		.of_match_table = of_match_ptr(of_pmic_regulator_match),
643 	},
644 	.probe = stpmic1_regulator_probe,
645 };
646 
647 module_platform_driver(stpmic1_regulator_driver);
648 
649 MODULE_DESCRIPTION("STPMIC1 PMIC voltage regulator driver");
650 MODULE_AUTHOR("Pascal Paillet <p.paillet@st.com>");
651 MODULE_LICENSE("GPL v2");
652